strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSConsole:
  785    '''
  786    AWSConsole is currently unstable, and its API may change, or it may be removed,
  787    without a major version bump.
  788    '''
  789    __slots__ = [
  790        'bind_interface',
  791        'egress_filter',
  792        'enable_env_variables',
  793        'healthy',
  794        'id',
  795        'name',
  796        'port_override',
  797        'region',
  798        'remote_identity_group_id',
  799        'remote_identity_healthcheck_username',
  800        'role_arn',
  801        'role_external_id',
  802        'secret_store_id',
  803        'session_expiry',
  804        'subdomain',
  805        'tags',
  806    ]
  807
  808    def __init__(
  809        self,
  810        bind_interface=None,
  811        egress_filter=None,
  812        enable_env_variables=None,
  813        healthy=None,
  814        id=None,
  815        name=None,
  816        port_override=None,
  817        region=None,
  818        remote_identity_group_id=None,
  819        remote_identity_healthcheck_username=None,
  820        role_arn=None,
  821        role_external_id=None,
  822        secret_store_id=None,
  823        session_expiry=None,
  824        subdomain=None,
  825        tags=None,
  826    ):
  827        self.bind_interface = bind_interface if bind_interface is not None else ''
  828        '''
  829         Bind interface
  830        '''
  831        self.egress_filter = egress_filter if egress_filter is not None else ''
  832        '''
  833         A filter applied to the routing logic to pin datasource to nodes.
  834        '''
  835        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
  836        self.healthy = healthy if healthy is not None else False
  837        '''
  838         True if the datasource is reachable and the credentials are valid.
  839        '''
  840        self.id = id if id is not None else ''
  841        '''
  842         Unique identifier of the Resource.
  843        '''
  844        self.name = name if name is not None else ''
  845        '''
  846         Unique human-readable name of the Resource.
  847        '''
  848        self.port_override = port_override if port_override is not None else 0
  849        self.region = region if region is not None else ''
  850        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  851        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  852        self.role_arn = role_arn if role_arn is not None else ''
  853        self.role_external_id = role_external_id if role_external_id is not None else ''
  854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  855        '''
  856         ID of the secret store containing credentials for this resource, if any.
  857        '''
  858        self.session_expiry = session_expiry if session_expiry is not None else 0
  859        self.subdomain = subdomain if subdomain is not None else ''
  860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  861        '''
  862         Tags is a map of key, value pairs.
  863        '''
  864
  865    def __repr__(self):
  866        return '<sdm.AWSConsole ' + \
  867            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  868            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  869            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
  870            'healthy: ' + repr(self.healthy) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'name: ' + repr(self.name) + ' ' +\
  873            'port_override: ' + repr(self.port_override) + ' ' +\
  874            'region: ' + repr(self.region) + ' ' +\
  875            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  876            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  877            'role_arn: ' + repr(self.role_arn) + ' ' +\
  878            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  880            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
  881            'subdomain: ' + repr(self.subdomain) + ' ' +\
  882            'tags: ' + repr(self.tags) + ' ' +\
  883            '>'
  884
  885    def to_dict(self):
  886        return {
  887            'bind_interface': self.bind_interface,
  888            'egress_filter': self.egress_filter,
  889            'enable_env_variables': self.enable_env_variables,
  890            'healthy': self.healthy,
  891            'id': self.id,
  892            'name': self.name,
  893            'port_override': self.port_override,
  894            'region': self.region,
  895            'remote_identity_group_id': self.remote_identity_group_id,
  896            'remote_identity_healthcheck_username':
  897            self.remote_identity_healthcheck_username,
  898            'role_arn': self.role_arn,
  899            'role_external_id': self.role_external_id,
  900            'secret_store_id': self.secret_store_id,
  901            'session_expiry': self.session_expiry,
  902            'subdomain': self.subdomain,
  903            'tags': self.tags,
  904        }
  905
  906    @classmethod
  907    def from_dict(cls, d):
  908        return cls(
  909            bind_interface=d.get('bind_interface'),
  910            egress_filter=d.get('egress_filter'),
  911            enable_env_variables=d.get('enable_env_variables'),
  912            healthy=d.get('healthy'),
  913            id=d.get('id'),
  914            name=d.get('name'),
  915            port_override=d.get('port_override'),
  916            region=d.get('region'),
  917            remote_identity_group_id=d.get('remote_identity_group_id'),
  918            remote_identity_healthcheck_username=d.get(
  919                'remote_identity_healthcheck_username'),
  920            role_arn=d.get('role_arn'),
  921            role_external_id=d.get('role_external_id'),
  922            secret_store_id=d.get('secret_store_id'),
  923            session_expiry=d.get('session_expiry'),
  924            subdomain=d.get('subdomain'),
  925            tags=d.get('tags'),
  926        )
  927
  928
  929class AWSConsoleStaticKeyPair:
  930    '''
  931    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
  932    without a major version bump.
  933    '''
  934    __slots__ = [
  935        'access_key',
  936        'bind_interface',
  937        'egress_filter',
  938        'healthy',
  939        'id',
  940        'name',
  941        'port_override',
  942        'region',
  943        'remote_identity_group_id',
  944        'remote_identity_healthcheck_username',
  945        'role_arn',
  946        'role_external_id',
  947        'secret_access_key',
  948        'secret_store_id',
  949        'session_expiry',
  950        'subdomain',
  951        'tags',
  952    ]
  953
  954    def __init__(
  955        self,
  956        access_key=None,
  957        bind_interface=None,
  958        egress_filter=None,
  959        healthy=None,
  960        id=None,
  961        name=None,
  962        port_override=None,
  963        region=None,
  964        remote_identity_group_id=None,
  965        remote_identity_healthcheck_username=None,
  966        role_arn=None,
  967        role_external_id=None,
  968        secret_access_key=None,
  969        secret_store_id=None,
  970        session_expiry=None,
  971        subdomain=None,
  972        tags=None,
  973    ):
  974        self.access_key = access_key if access_key is not None else ''
  975        self.bind_interface = bind_interface if bind_interface is not None else ''
  976        '''
  977         Bind interface
  978        '''
  979        self.egress_filter = egress_filter if egress_filter is not None else ''
  980        '''
  981         A filter applied to the routing logic to pin datasource to nodes.
  982        '''
  983        self.healthy = healthy if healthy is not None else False
  984        '''
  985         True if the datasource is reachable and the credentials are valid.
  986        '''
  987        self.id = id if id is not None else ''
  988        '''
  989         Unique identifier of the Resource.
  990        '''
  991        self.name = name if name is not None else ''
  992        '''
  993         Unique human-readable name of the Resource.
  994        '''
  995        self.port_override = port_override if port_override is not None else 0
  996        self.region = region if region is not None else ''
  997        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  998        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  999        self.role_arn = role_arn if role_arn is not None else ''
 1000        self.role_external_id = role_external_id if role_external_id is not None else ''
 1001        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1002        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1003        '''
 1004         ID of the secret store containing credentials for this resource, if any.
 1005        '''
 1006        self.session_expiry = session_expiry if session_expiry is not None else 0
 1007        self.subdomain = subdomain if subdomain is not None else ''
 1008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1009        '''
 1010         Tags is a map of key, value pairs.
 1011        '''
 1012
 1013    def __repr__(self):
 1014        return '<sdm.AWSConsoleStaticKeyPair ' + \
 1015            'access_key: ' + repr(self.access_key) + ' ' +\
 1016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1018            'healthy: ' + repr(self.healthy) + ' ' +\
 1019            'id: ' + repr(self.id) + ' ' +\
 1020            'name: ' + repr(self.name) + ' ' +\
 1021            'port_override: ' + repr(self.port_override) + ' ' +\
 1022            'region: ' + repr(self.region) + ' ' +\
 1023            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1024            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1025            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1026            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1027            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1029            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
 1030            'subdomain: ' + repr(self.subdomain) + ' ' +\
 1031            'tags: ' + repr(self.tags) + ' ' +\
 1032            '>'
 1033
 1034    def to_dict(self):
 1035        return {
 1036            'access_key': self.access_key,
 1037            'bind_interface': self.bind_interface,
 1038            'egress_filter': self.egress_filter,
 1039            'healthy': self.healthy,
 1040            'id': self.id,
 1041            'name': self.name,
 1042            'port_override': self.port_override,
 1043            'region': self.region,
 1044            'remote_identity_group_id': self.remote_identity_group_id,
 1045            'remote_identity_healthcheck_username':
 1046            self.remote_identity_healthcheck_username,
 1047            'role_arn': self.role_arn,
 1048            'role_external_id': self.role_external_id,
 1049            'secret_access_key': self.secret_access_key,
 1050            'secret_store_id': self.secret_store_id,
 1051            'session_expiry': self.session_expiry,
 1052            'subdomain': self.subdomain,
 1053            'tags': self.tags,
 1054        }
 1055
 1056    @classmethod
 1057    def from_dict(cls, d):
 1058        return cls(
 1059            access_key=d.get('access_key'),
 1060            bind_interface=d.get('bind_interface'),
 1061            egress_filter=d.get('egress_filter'),
 1062            healthy=d.get('healthy'),
 1063            id=d.get('id'),
 1064            name=d.get('name'),
 1065            port_override=d.get('port_override'),
 1066            region=d.get('region'),
 1067            remote_identity_group_id=d.get('remote_identity_group_id'),
 1068            remote_identity_healthcheck_username=d.get(
 1069                'remote_identity_healthcheck_username'),
 1070            role_arn=d.get('role_arn'),
 1071            role_external_id=d.get('role_external_id'),
 1072            secret_access_key=d.get('secret_access_key'),
 1073            secret_store_id=d.get('secret_store_id'),
 1074            session_expiry=d.get('session_expiry'),
 1075            subdomain=d.get('subdomain'),
 1076            tags=d.get('tags'),
 1077        )
 1078
 1079
 1080class AWSStore:
 1081    __slots__ = [
 1082        'id',
 1083        'name',
 1084        'region',
 1085        'tags',
 1086    ]
 1087
 1088    def __init__(
 1089        self,
 1090        id=None,
 1091        name=None,
 1092        region=None,
 1093        tags=None,
 1094    ):
 1095        self.id = id if id is not None else ''
 1096        '''
 1097         Unique identifier of the SecretStore.
 1098        '''
 1099        self.name = name if name is not None else ''
 1100        '''
 1101         Unique human-readable name of the SecretStore.
 1102        '''
 1103        self.region = region if region is not None else ''
 1104        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1105        '''
 1106         Tags is a map of key, value pairs.
 1107        '''
 1108
 1109    def __repr__(self):
 1110        return '<sdm.AWSStore ' + \
 1111            'id: ' + repr(self.id) + ' ' +\
 1112            'name: ' + repr(self.name) + ' ' +\
 1113            'region: ' + repr(self.region) + ' ' +\
 1114            'tags: ' + repr(self.tags) + ' ' +\
 1115            '>'
 1116
 1117    def to_dict(self):
 1118        return {
 1119            'id': self.id,
 1120            'name': self.name,
 1121            'region': self.region,
 1122            'tags': self.tags,
 1123        }
 1124
 1125    @classmethod
 1126    def from_dict(cls, d):
 1127        return cls(
 1128            id=d.get('id'),
 1129            name=d.get('name'),
 1130            region=d.get('region'),
 1131            tags=d.get('tags'),
 1132        )
 1133
 1134
 1135class AccountAttachment:
 1136    '''
 1137         AccountAttachments assign an account to a role.
 1138    '''
 1139    __slots__ = [
 1140        'account_id',
 1141        'id',
 1142        'role_id',
 1143    ]
 1144
 1145    def __init__(
 1146        self,
 1147        account_id=None,
 1148        id=None,
 1149        role_id=None,
 1150    ):
 1151        self.account_id = account_id if account_id is not None else ''
 1152        '''
 1153         The id of the account of this AccountAttachment.
 1154        '''
 1155        self.id = id if id is not None else ''
 1156        '''
 1157         Unique identifier of the AccountAttachment.
 1158        '''
 1159        self.role_id = role_id if role_id is not None else ''
 1160        '''
 1161         The id of the attached role of this AccountAttachment.
 1162        '''
 1163
 1164    def __repr__(self):
 1165        return '<sdm.AccountAttachment ' + \
 1166            'account_id: ' + repr(self.account_id) + ' ' +\
 1167            'id: ' + repr(self.id) + ' ' +\
 1168            'role_id: ' + repr(self.role_id) + ' ' +\
 1169            '>'
 1170
 1171    def to_dict(self):
 1172        return {
 1173            'account_id': self.account_id,
 1174            'id': self.id,
 1175            'role_id': self.role_id,
 1176        }
 1177
 1178    @classmethod
 1179    def from_dict(cls, d):
 1180        return cls(
 1181            account_id=d.get('account_id'),
 1182            id=d.get('id'),
 1183            role_id=d.get('role_id'),
 1184        )
 1185
 1186
 1187class AccountAttachmentCreateResponse:
 1188    '''
 1189         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1190    '''
 1191    __slots__ = [
 1192        'account_attachment',
 1193        'meta',
 1194        'rate_limit',
 1195    ]
 1196
 1197    def __init__(
 1198        self,
 1199        account_attachment=None,
 1200        meta=None,
 1201        rate_limit=None,
 1202    ):
 1203        self.account_attachment = account_attachment if account_attachment is not None else None
 1204        '''
 1205         The created AccountAttachment.
 1206        '''
 1207        self.meta = meta if meta is not None else None
 1208        '''
 1209         Reserved for future use.
 1210        '''
 1211        self.rate_limit = rate_limit if rate_limit is not None else None
 1212        '''
 1213         Rate limit information.
 1214        '''
 1215
 1216    def __repr__(self):
 1217        return '<sdm.AccountAttachmentCreateResponse ' + \
 1218            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1219            'meta: ' + repr(self.meta) + ' ' +\
 1220            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1221            '>'
 1222
 1223    def to_dict(self):
 1224        return {
 1225            'account_attachment': self.account_attachment,
 1226            'meta': self.meta,
 1227            'rate_limit': self.rate_limit,
 1228        }
 1229
 1230    @classmethod
 1231    def from_dict(cls, d):
 1232        return cls(
 1233            account_attachment=d.get('account_attachment'),
 1234            meta=d.get('meta'),
 1235            rate_limit=d.get('rate_limit'),
 1236        )
 1237
 1238
 1239class AccountAttachmentDeleteResponse:
 1240    '''
 1241         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1242    '''
 1243    __slots__ = [
 1244        'meta',
 1245        'rate_limit',
 1246    ]
 1247
 1248    def __init__(
 1249        self,
 1250        meta=None,
 1251        rate_limit=None,
 1252    ):
 1253        self.meta = meta if meta is not None else None
 1254        '''
 1255         Reserved for future use.
 1256        '''
 1257        self.rate_limit = rate_limit if rate_limit is not None else None
 1258        '''
 1259         Rate limit information.
 1260        '''
 1261
 1262    def __repr__(self):
 1263        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1264            'meta: ' + repr(self.meta) + ' ' +\
 1265            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1266            '>'
 1267
 1268    def to_dict(self):
 1269        return {
 1270            'meta': self.meta,
 1271            'rate_limit': self.rate_limit,
 1272        }
 1273
 1274    @classmethod
 1275    def from_dict(cls, d):
 1276        return cls(
 1277            meta=d.get('meta'),
 1278            rate_limit=d.get('rate_limit'),
 1279        )
 1280
 1281
 1282class AccountAttachmentGetResponse:
 1283    '''
 1284         AccountAttachmentGetResponse returns a requested AccountAttachment.
 1285    '''
 1286    __slots__ = [
 1287        'account_attachment',
 1288        'meta',
 1289        'rate_limit',
 1290    ]
 1291
 1292    def __init__(
 1293        self,
 1294        account_attachment=None,
 1295        meta=None,
 1296        rate_limit=None,
 1297    ):
 1298        self.account_attachment = account_attachment if account_attachment is not None else None
 1299        '''
 1300         The requested AccountAttachment.
 1301        '''
 1302        self.meta = meta if meta is not None else None
 1303        '''
 1304         Reserved for future use.
 1305        '''
 1306        self.rate_limit = rate_limit if rate_limit is not None else None
 1307        '''
 1308         Rate limit information.
 1309        '''
 1310
 1311    def __repr__(self):
 1312        return '<sdm.AccountAttachmentGetResponse ' + \
 1313            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1314            'meta: ' + repr(self.meta) + ' ' +\
 1315            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1316            '>'
 1317
 1318    def to_dict(self):
 1319        return {
 1320            'account_attachment': self.account_attachment,
 1321            'meta': self.meta,
 1322            'rate_limit': self.rate_limit,
 1323        }
 1324
 1325    @classmethod
 1326    def from_dict(cls, d):
 1327        return cls(
 1328            account_attachment=d.get('account_attachment'),
 1329            meta=d.get('meta'),
 1330            rate_limit=d.get('rate_limit'),
 1331        )
 1332
 1333
 1334class AccountCreateResponse:
 1335    '''
 1336         AccountCreateResponse reports how the Accounts were created in the system.
 1337    '''
 1338    __slots__ = [
 1339        'account',
 1340        'meta',
 1341        'rate_limit',
 1342        'token',
 1343    ]
 1344
 1345    def __init__(
 1346        self,
 1347        account=None,
 1348        meta=None,
 1349        rate_limit=None,
 1350        token=None,
 1351    ):
 1352        self.account = account if account is not None else None
 1353        '''
 1354         The created Account.
 1355        '''
 1356        self.meta = meta if meta is not None else None
 1357        '''
 1358         Reserved for future use.
 1359        '''
 1360        self.rate_limit = rate_limit if rate_limit is not None else None
 1361        '''
 1362         Rate limit information.
 1363        '''
 1364        self.token = token if token is not None else ''
 1365        '''
 1366         The auth token generated for the Account. The Account will use this token to
 1367         authenticate with the strongDM API.
 1368        '''
 1369
 1370    def __repr__(self):
 1371        return '<sdm.AccountCreateResponse ' + \
 1372            'account: ' + repr(self.account) + ' ' +\
 1373            'meta: ' + repr(self.meta) + ' ' +\
 1374            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1375            'token: ' + repr(self.token) + ' ' +\
 1376            '>'
 1377
 1378    def to_dict(self):
 1379        return {
 1380            'account': self.account,
 1381            'meta': self.meta,
 1382            'rate_limit': self.rate_limit,
 1383            'token': self.token,
 1384        }
 1385
 1386    @classmethod
 1387    def from_dict(cls, d):
 1388        return cls(
 1389            account=d.get('account'),
 1390            meta=d.get('meta'),
 1391            rate_limit=d.get('rate_limit'),
 1392            token=d.get('token'),
 1393        )
 1394
 1395
 1396class AccountDeleteResponse:
 1397    '''
 1398         AccountDeleteResponse returns information about a Account that was deleted.
 1399    '''
 1400    __slots__ = [
 1401        'meta',
 1402        'rate_limit',
 1403    ]
 1404
 1405    def __init__(
 1406        self,
 1407        meta=None,
 1408        rate_limit=None,
 1409    ):
 1410        self.meta = meta if meta is not None else None
 1411        '''
 1412         Reserved for future use.
 1413        '''
 1414        self.rate_limit = rate_limit if rate_limit is not None else None
 1415        '''
 1416         Rate limit information.
 1417        '''
 1418
 1419    def __repr__(self):
 1420        return '<sdm.AccountDeleteResponse ' + \
 1421            'meta: ' + repr(self.meta) + ' ' +\
 1422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1423            '>'
 1424
 1425    def to_dict(self):
 1426        return {
 1427            'meta': self.meta,
 1428            'rate_limit': self.rate_limit,
 1429        }
 1430
 1431    @classmethod
 1432    def from_dict(cls, d):
 1433        return cls(
 1434            meta=d.get('meta'),
 1435            rate_limit=d.get('rate_limit'),
 1436        )
 1437
 1438
 1439class AccountGetResponse:
 1440    '''
 1441         AccountGetResponse returns a requested Account.
 1442    '''
 1443    __slots__ = [
 1444        'account',
 1445        'meta',
 1446        'rate_limit',
 1447    ]
 1448
 1449    def __init__(
 1450        self,
 1451        account=None,
 1452        meta=None,
 1453        rate_limit=None,
 1454    ):
 1455        self.account = account if account is not None else None
 1456        '''
 1457         The requested Account.
 1458        '''
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGetResponse ' + \
 1470            'account: ' + repr(self.account) + ' ' +\
 1471            'meta: ' + repr(self.meta) + ' ' +\
 1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1473            '>'
 1474
 1475    def to_dict(self):
 1476        return {
 1477            'account': self.account,
 1478            'meta': self.meta,
 1479            'rate_limit': self.rate_limit,
 1480        }
 1481
 1482    @classmethod
 1483    def from_dict(cls, d):
 1484        return cls(
 1485            account=d.get('account'),
 1486            meta=d.get('meta'),
 1487            rate_limit=d.get('rate_limit'),
 1488        )
 1489
 1490
 1491class AccountGrant:
 1492    '''
 1493         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1494    '''
 1495    __slots__ = [
 1496        'account_id',
 1497        'id',
 1498        'resource_id',
 1499        'start_from',
 1500        'valid_until',
 1501    ]
 1502
 1503    def __init__(
 1504        self,
 1505        account_id=None,
 1506        id=None,
 1507        resource_id=None,
 1508        start_from=None,
 1509        valid_until=None,
 1510    ):
 1511        self.account_id = account_id if account_id is not None else ''
 1512        '''
 1513         The account ID of this AccountGrant.
 1514        '''
 1515        self.id = id if id is not None else ''
 1516        '''
 1517         Unique identifier of the AccountGrant.
 1518        '''
 1519        self.resource_id = resource_id if resource_id is not None else ''
 1520        '''
 1521         The resource ID of this AccountGrant.
 1522        '''
 1523        self.start_from = start_from if start_from is not None else None
 1524        '''
 1525         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1526        '''
 1527        self.valid_until = valid_until if valid_until is not None else None
 1528        '''
 1529         The timestamp when the resource grant will expire.
 1530        '''
 1531
 1532    def __repr__(self):
 1533        return '<sdm.AccountGrant ' + \
 1534            'account_id: ' + repr(self.account_id) + ' ' +\
 1535            'id: ' + repr(self.id) + ' ' +\
 1536            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1537            'start_from: ' + repr(self.start_from) + ' ' +\
 1538            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1539            '>'
 1540
 1541    def to_dict(self):
 1542        return {
 1543            'account_id': self.account_id,
 1544            'id': self.id,
 1545            'resource_id': self.resource_id,
 1546            'start_from': self.start_from,
 1547            'valid_until': self.valid_until,
 1548        }
 1549
 1550    @classmethod
 1551    def from_dict(cls, d):
 1552        return cls(
 1553            account_id=d.get('account_id'),
 1554            id=d.get('id'),
 1555            resource_id=d.get('resource_id'),
 1556            start_from=d.get('start_from'),
 1557            valid_until=d.get('valid_until'),
 1558        )
 1559
 1560
 1561class AccountGrantCreateResponse:
 1562    '''
 1563         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1564    '''
 1565    __slots__ = [
 1566        'account_grant',
 1567        'meta',
 1568        'rate_limit',
 1569    ]
 1570
 1571    def __init__(
 1572        self,
 1573        account_grant=None,
 1574        meta=None,
 1575        rate_limit=None,
 1576    ):
 1577        self.account_grant = account_grant if account_grant is not None else None
 1578        '''
 1579         The created AccountGrant.
 1580        '''
 1581        self.meta = meta if meta is not None else None
 1582        '''
 1583         Reserved for future use.
 1584        '''
 1585        self.rate_limit = rate_limit if rate_limit is not None else None
 1586        '''
 1587         Rate limit information.
 1588        '''
 1589
 1590    def __repr__(self):
 1591        return '<sdm.AccountGrantCreateResponse ' + \
 1592            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1593            'meta: ' + repr(self.meta) + ' ' +\
 1594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1595            '>'
 1596
 1597    def to_dict(self):
 1598        return {
 1599            'account_grant': self.account_grant,
 1600            'meta': self.meta,
 1601            'rate_limit': self.rate_limit,
 1602        }
 1603
 1604    @classmethod
 1605    def from_dict(cls, d):
 1606        return cls(
 1607            account_grant=d.get('account_grant'),
 1608            meta=d.get('meta'),
 1609            rate_limit=d.get('rate_limit'),
 1610        )
 1611
 1612
 1613class AccountGrantDeleteResponse:
 1614    '''
 1615         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1616    '''
 1617    __slots__ = [
 1618        'meta',
 1619        'rate_limit',
 1620    ]
 1621
 1622    def __init__(
 1623        self,
 1624        meta=None,
 1625        rate_limit=None,
 1626    ):
 1627        self.meta = meta if meta is not None else None
 1628        '''
 1629         Reserved for future use.
 1630        '''
 1631        self.rate_limit = rate_limit if rate_limit is not None else None
 1632        '''
 1633         Rate limit information.
 1634        '''
 1635
 1636    def __repr__(self):
 1637        return '<sdm.AccountGrantDeleteResponse ' + \
 1638            'meta: ' + repr(self.meta) + ' ' +\
 1639            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1640            '>'
 1641
 1642    def to_dict(self):
 1643        return {
 1644            'meta': self.meta,
 1645            'rate_limit': self.rate_limit,
 1646        }
 1647
 1648    @classmethod
 1649    def from_dict(cls, d):
 1650        return cls(
 1651            meta=d.get('meta'),
 1652            rate_limit=d.get('rate_limit'),
 1653        )
 1654
 1655
 1656class AccountGrantGetResponse:
 1657    '''
 1658         AccountGrantGetResponse returns a requested AccountGrant.
 1659    '''
 1660    __slots__ = [
 1661        'account_grant',
 1662        'meta',
 1663        'rate_limit',
 1664    ]
 1665
 1666    def __init__(
 1667        self,
 1668        account_grant=None,
 1669        meta=None,
 1670        rate_limit=None,
 1671    ):
 1672        self.account_grant = account_grant if account_grant is not None else None
 1673        '''
 1674         The requested AccountGrant.
 1675        '''
 1676        self.meta = meta if meta is not None else None
 1677        '''
 1678         Reserved for future use.
 1679        '''
 1680        self.rate_limit = rate_limit if rate_limit is not None else None
 1681        '''
 1682         Rate limit information.
 1683        '''
 1684
 1685    def __repr__(self):
 1686        return '<sdm.AccountGrantGetResponse ' + \
 1687            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1688            'meta: ' + repr(self.meta) + ' ' +\
 1689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1690            '>'
 1691
 1692    def to_dict(self):
 1693        return {
 1694            'account_grant': self.account_grant,
 1695            'meta': self.meta,
 1696            'rate_limit': self.rate_limit,
 1697        }
 1698
 1699    @classmethod
 1700    def from_dict(cls, d):
 1701        return cls(
 1702            account_grant=d.get('account_grant'),
 1703            meta=d.get('meta'),
 1704            rate_limit=d.get('rate_limit'),
 1705        )
 1706
 1707
 1708class AccountUpdateResponse:
 1709    '''
 1710         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1711     a AccountUpdateRequest.
 1712    '''
 1713    __slots__ = [
 1714        'account',
 1715        'meta',
 1716        'rate_limit',
 1717    ]
 1718
 1719    def __init__(
 1720        self,
 1721        account=None,
 1722        meta=None,
 1723        rate_limit=None,
 1724    ):
 1725        self.account = account if account is not None else None
 1726        '''
 1727         The updated Account.
 1728        '''
 1729        self.meta = meta if meta is not None else None
 1730        '''
 1731         Reserved for future use.
 1732        '''
 1733        self.rate_limit = rate_limit if rate_limit is not None else None
 1734        '''
 1735         Rate limit information.
 1736        '''
 1737
 1738    def __repr__(self):
 1739        return '<sdm.AccountUpdateResponse ' + \
 1740            'account: ' + repr(self.account) + ' ' +\
 1741            'meta: ' + repr(self.meta) + ' ' +\
 1742            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1743            '>'
 1744
 1745    def to_dict(self):
 1746        return {
 1747            'account': self.account,
 1748            'meta': self.meta,
 1749            'rate_limit': self.rate_limit,
 1750        }
 1751
 1752    @classmethod
 1753    def from_dict(cls, d):
 1754        return cls(
 1755            account=d.get('account'),
 1756            meta=d.get('meta'),
 1757            rate_limit=d.get('rate_limit'),
 1758        )
 1759
 1760
 1761class AmazonEKS:
 1762    __slots__ = [
 1763        'access_key',
 1764        'bind_interface',
 1765        'certificate_authority',
 1766        'cluster_name',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthcheck_namespace',
 1770        'healthy',
 1771        'id',
 1772        'name',
 1773        'region',
 1774        'remote_identity_group_id',
 1775        'remote_identity_healthcheck_username',
 1776        'role_arn',
 1777        'role_external_id',
 1778        'secret_access_key',
 1779        'secret_store_id',
 1780        'tags',
 1781    ]
 1782
 1783    def __init__(
 1784        self,
 1785        access_key=None,
 1786        bind_interface=None,
 1787        certificate_authority=None,
 1788        cluster_name=None,
 1789        egress_filter=None,
 1790        endpoint=None,
 1791        healthcheck_namespace=None,
 1792        healthy=None,
 1793        id=None,
 1794        name=None,
 1795        region=None,
 1796        remote_identity_group_id=None,
 1797        remote_identity_healthcheck_username=None,
 1798        role_arn=None,
 1799        role_external_id=None,
 1800        secret_access_key=None,
 1801        secret_store_id=None,
 1802        tags=None,
 1803    ):
 1804        self.access_key = access_key if access_key is not None else ''
 1805        self.bind_interface = bind_interface if bind_interface is not None else ''
 1806        '''
 1807         Bind interface
 1808        '''
 1809        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1810        self.cluster_name = cluster_name if cluster_name is not None else ''
 1811        self.egress_filter = egress_filter if egress_filter is not None else ''
 1812        '''
 1813         A filter applied to the routing logic to pin datasource to nodes.
 1814        '''
 1815        self.endpoint = endpoint if endpoint is not None else ''
 1816        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1817        '''
 1818         The path used to check the health of your connection.  Defaults to `default`.
 1819        '''
 1820        self.healthy = healthy if healthy is not None else False
 1821        '''
 1822         True if the datasource is reachable and the credentials are valid.
 1823        '''
 1824        self.id = id if id is not None else ''
 1825        '''
 1826         Unique identifier of the Resource.
 1827        '''
 1828        self.name = name if name is not None else ''
 1829        '''
 1830         Unique human-readable name of the Resource.
 1831        '''
 1832        self.region = region if region is not None else ''
 1833        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1834        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1835        self.role_arn = role_arn if role_arn is not None else ''
 1836        self.role_external_id = role_external_id if role_external_id is not None else ''
 1837        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1839        '''
 1840         ID of the secret store containing credentials for this resource, if any.
 1841        '''
 1842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1843        '''
 1844         Tags is a map of key, value pairs.
 1845        '''
 1846
 1847    def __repr__(self):
 1848        return '<sdm.AmazonEKS ' + \
 1849            'access_key: ' + repr(self.access_key) + ' ' +\
 1850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1851            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1852            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1854            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1855            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1856            'healthy: ' + repr(self.healthy) + ' ' +\
 1857            'id: ' + repr(self.id) + ' ' +\
 1858            'name: ' + repr(self.name) + ' ' +\
 1859            'region: ' + repr(self.region) + ' ' +\
 1860            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1861            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1862            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1863            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1864            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1865            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1866            'tags: ' + repr(self.tags) + ' ' +\
 1867            '>'
 1868
 1869    def to_dict(self):
 1870        return {
 1871            'access_key': self.access_key,
 1872            'bind_interface': self.bind_interface,
 1873            'certificate_authority': self.certificate_authority,
 1874            'cluster_name': self.cluster_name,
 1875            'egress_filter': self.egress_filter,
 1876            'endpoint': self.endpoint,
 1877            'healthcheck_namespace': self.healthcheck_namespace,
 1878            'healthy': self.healthy,
 1879            'id': self.id,
 1880            'name': self.name,
 1881            'region': self.region,
 1882            'remote_identity_group_id': self.remote_identity_group_id,
 1883            'remote_identity_healthcheck_username':
 1884            self.remote_identity_healthcheck_username,
 1885            'role_arn': self.role_arn,
 1886            'role_external_id': self.role_external_id,
 1887            'secret_access_key': self.secret_access_key,
 1888            'secret_store_id': self.secret_store_id,
 1889            'tags': self.tags,
 1890        }
 1891
 1892    @classmethod
 1893    def from_dict(cls, d):
 1894        return cls(
 1895            access_key=d.get('access_key'),
 1896            bind_interface=d.get('bind_interface'),
 1897            certificate_authority=d.get('certificate_authority'),
 1898            cluster_name=d.get('cluster_name'),
 1899            egress_filter=d.get('egress_filter'),
 1900            endpoint=d.get('endpoint'),
 1901            healthcheck_namespace=d.get('healthcheck_namespace'),
 1902            healthy=d.get('healthy'),
 1903            id=d.get('id'),
 1904            name=d.get('name'),
 1905            region=d.get('region'),
 1906            remote_identity_group_id=d.get('remote_identity_group_id'),
 1907            remote_identity_healthcheck_username=d.get(
 1908                'remote_identity_healthcheck_username'),
 1909            role_arn=d.get('role_arn'),
 1910            role_external_id=d.get('role_external_id'),
 1911            secret_access_key=d.get('secret_access_key'),
 1912            secret_store_id=d.get('secret_store_id'),
 1913            tags=d.get('tags'),
 1914        )
 1915
 1916
 1917class AmazonEKSInstanceProfile:
 1918    '''
 1919    AmazonEKSInstanceProfile is currently unstable, and its API may change, or it may be removed,
 1920    without a major version bump.
 1921    '''
 1922    __slots__ = [
 1923        'bind_interface',
 1924        'certificate_authority',
 1925        'cluster_name',
 1926        'egress_filter',
 1927        'endpoint',
 1928        'healthcheck_namespace',
 1929        'healthy',
 1930        'id',
 1931        'name',
 1932        'region',
 1933        'remote_identity_group_id',
 1934        'remote_identity_healthcheck_username',
 1935        'role_arn',
 1936        'role_external_id',
 1937        'secret_store_id',
 1938        'tags',
 1939    ]
 1940
 1941    def __init__(
 1942        self,
 1943        bind_interface=None,
 1944        certificate_authority=None,
 1945        cluster_name=None,
 1946        egress_filter=None,
 1947        endpoint=None,
 1948        healthcheck_namespace=None,
 1949        healthy=None,
 1950        id=None,
 1951        name=None,
 1952        region=None,
 1953        remote_identity_group_id=None,
 1954        remote_identity_healthcheck_username=None,
 1955        role_arn=None,
 1956        role_external_id=None,
 1957        secret_store_id=None,
 1958        tags=None,
 1959    ):
 1960        self.bind_interface = bind_interface if bind_interface is not None else ''
 1961        '''
 1962         Bind interface
 1963        '''
 1964        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1965        self.cluster_name = cluster_name if cluster_name is not None else ''
 1966        self.egress_filter = egress_filter if egress_filter is not None else ''
 1967        '''
 1968         A filter applied to the routing logic to pin datasource to nodes.
 1969        '''
 1970        self.endpoint = endpoint if endpoint is not None else ''
 1971        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1972        '''
 1973         The path used to check the health of your connection.  Defaults to `default`.
 1974        '''
 1975        self.healthy = healthy if healthy is not None else False
 1976        '''
 1977         True if the datasource is reachable and the credentials are valid.
 1978        '''
 1979        self.id = id if id is not None else ''
 1980        '''
 1981         Unique identifier of the Resource.
 1982        '''
 1983        self.name = name if name is not None else ''
 1984        '''
 1985         Unique human-readable name of the Resource.
 1986        '''
 1987        self.region = region if region is not None else ''
 1988        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1989        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1990        self.role_arn = role_arn if role_arn is not None else ''
 1991        self.role_external_id = role_external_id if role_external_id is not None else ''
 1992        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1993        '''
 1994         ID of the secret store containing credentials for this resource, if any.
 1995        '''
 1996        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1997        '''
 1998         Tags is a map of key, value pairs.
 1999        '''
 2000
 2001    def __repr__(self):
 2002        return '<sdm.AmazonEKSInstanceProfile ' + \
 2003            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2004            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 2005            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 2006            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2007            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2008            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 2009            'healthy: ' + repr(self.healthy) + ' ' +\
 2010            'id: ' + repr(self.id) + ' ' +\
 2011            'name: ' + repr(self.name) + ' ' +\
 2012            'region: ' + repr(self.region) + ' ' +\
 2013            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 2014            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 2015            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2016            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2017            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2018            'tags: ' + repr(self.tags) + ' ' +\
 2019            '>'
 2020
 2021    def to_dict(self):
 2022        return {
 2023            'bind_interface': self.bind_interface,
 2024            'certificate_authority': self.certificate_authority,
 2025            'cluster_name': self.cluster_name,
 2026            'egress_filter': self.egress_filter,
 2027            'endpoint': self.endpoint,
 2028            'healthcheck_namespace': self.healthcheck_namespace,
 2029            'healthy': self.healthy,
 2030            'id': self.id,
 2031            'name': self.name,
 2032            'region': self.region,
 2033            'remote_identity_group_id': self.remote_identity_group_id,
 2034            'remote_identity_healthcheck_username':
 2035            self.remote_identity_healthcheck_username,
 2036            'role_arn': self.role_arn,
 2037            'role_external_id': self.role_external_id,
 2038            'secret_store_id': self.secret_store_id,
 2039            'tags': self.tags,
 2040        }
 2041
 2042    @classmethod
 2043    def from_dict(cls, d):
 2044        return cls(
 2045            bind_interface=d.get('bind_interface'),
 2046            certificate_authority=d.get('certificate_authority'),
 2047            cluster_name=d.get('cluster_name'),
 2048            egress_filter=d.get('egress_filter'),
 2049            endpoint=d.get('endpoint'),
 2050            healthcheck_namespace=d.get('healthcheck_namespace'),
 2051            healthy=d.get('healthy'),
 2052            id=d.get('id'),
 2053            name=d.get('name'),
 2054            region=d.get('region'),
 2055            remote_identity_group_id=d.get('remote_identity_group_id'),
 2056            remote_identity_healthcheck_username=d.get(
 2057                'remote_identity_healthcheck_username'),
 2058            role_arn=d.get('role_arn'),
 2059            role_external_id=d.get('role_external_id'),
 2060            secret_store_id=d.get('secret_store_id'),
 2061            tags=d.get('tags'),
 2062        )
 2063
 2064
 2065class AmazonEKSUserImpersonation:
 2066    __slots__ = [
 2067        'access_key',
 2068        'bind_interface',
 2069        'certificate_authority',
 2070        'cluster_name',
 2071        'egress_filter',
 2072        'endpoint',
 2073        'healthcheck_namespace',
 2074        'healthy',
 2075        'id',
 2076        'name',
 2077        'region',
 2078        'role_arn',
 2079        'role_external_id',
 2080        'secret_access_key',
 2081        'secret_store_id',
 2082        'tags',
 2083    ]
 2084
 2085    def __init__(
 2086        self,
 2087        access_key=None,
 2088        bind_interface=None,
 2089        certificate_authority=None,
 2090        cluster_name=None,
 2091        egress_filter=None,
 2092        endpoint=None,
 2093        healthcheck_namespace=None,
 2094        healthy=None,
 2095        id=None,
 2096        name=None,
 2097        region=None,
 2098        role_arn=None,
 2099        role_external_id=None,
 2100        secret_access_key=None,
 2101        secret_store_id=None,
 2102        tags=None,
 2103    ):
 2104        self.access_key = access_key if access_key is not None else ''
 2105        self.bind_interface = bind_interface if bind_interface is not None else ''
 2106        '''
 2107         Bind interface
 2108        '''
 2109        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 2110        self.cluster_name = cluster_name if cluster_name is not None else ''
 2111        self.egress_filter = egress_filter if egress_filter is not None else ''
 2112        '''
 2113         A filter applied to the routing logic to pin datasource to nodes.
 2114        '''
 2115        self.endpoint = endpoint if endpoint is not None else ''
 2116        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 2117        '''
 2118         The path used to check the health of your connection.  Defaults to `default`.
 2119        '''
 2120        self.healthy = healthy if healthy is not None else False
 2121        '''
 2122         True if the datasource is reachable and the credentials are valid.
 2123        '''
 2124        self.id = id if id is not None else ''
 2125        '''
 2126         Unique identifier of the Resource.
 2127        '''
 2128        self.name = name if name is not None else ''
 2129        '''
 2130         Unique human-readable name of the Resource.
 2131        '''
 2132        self.region = region if region is not None else ''
 2133        self.role_arn = role_arn if role_arn is not None else ''
 2134        self.role_external_id = role_external_id if role_external_id is not None else ''
 2135        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2136        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2137        '''
 2138         ID of the secret store containing credentials for this resource, if any.
 2139        '''
 2140        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2141        '''
 2142         Tags is a map of key, value pairs.
 2143        '''
 2144
 2145    def __repr__(self):
 2146        return '<sdm.AmazonEKSUserImpersonation ' + \
 2147            'access_key: ' + repr(self.access_key) + ' ' +\
 2148            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2149            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 2150            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 2151            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2152            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2153            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 2154            'healthy: ' + repr(self.healthy) + ' ' +\
 2155            'id: ' + repr(self.id) + ' ' +\
 2156            'name: ' + repr(self.name) + ' ' +\
 2157            'region: ' + repr(self.region) + ' ' +\
 2158            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2159            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2160            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2161            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2162            'tags: ' + repr(self.tags) + ' ' +\
 2163            '>'
 2164
 2165    def to_dict(self):
 2166        return {
 2167            'access_key': self.access_key,
 2168            'bind_interface': self.bind_interface,
 2169            'certificate_authority': self.certificate_authority,
 2170            'cluster_name': self.cluster_name,
 2171            'egress_filter': self.egress_filter,
 2172            'endpoint': self.endpoint,
 2173            'healthcheck_namespace': self.healthcheck_namespace,
 2174            'healthy': self.healthy,
 2175            'id': self.id,
 2176            'name': self.name,
 2177            'region': self.region,
 2178            'role_arn': self.role_arn,
 2179            'role_external_id': self.role_external_id,
 2180            'secret_access_key': self.secret_access_key,
 2181            'secret_store_id': self.secret_store_id,
 2182            'tags': self.tags,
 2183        }
 2184
 2185    @classmethod
 2186    def from_dict(cls, d):
 2187        return cls(
 2188            access_key=d.get('access_key'),
 2189            bind_interface=d.get('bind_interface'),
 2190            certificate_authority=d.get('certificate_authority'),
 2191            cluster_name=d.get('cluster_name'),
 2192            egress_filter=d.get('egress_filter'),
 2193            endpoint=d.get('endpoint'),
 2194            healthcheck_namespace=d.get('healthcheck_namespace'),
 2195            healthy=d.get('healthy'),
 2196            id=d.get('id'),
 2197            name=d.get('name'),
 2198            region=d.get('region'),
 2199            role_arn=d.get('role_arn'),
 2200            role_external_id=d.get('role_external_id'),
 2201            secret_access_key=d.get('secret_access_key'),
 2202            secret_store_id=d.get('secret_store_id'),
 2203            tags=d.get('tags'),
 2204        )
 2205
 2206
 2207class AmazonES:
 2208    __slots__ = [
 2209        'access_key',
 2210        'bind_interface',
 2211        'egress_filter',
 2212        'endpoint',
 2213        'healthy',
 2214        'id',
 2215        'name',
 2216        'port_override',
 2217        'region',
 2218        'role_arn',
 2219        'role_external_id',
 2220        'secret_access_key',
 2221        'secret_store_id',
 2222        'tags',
 2223    ]
 2224
 2225    def __init__(
 2226        self,
 2227        access_key=None,
 2228        bind_interface=None,
 2229        egress_filter=None,
 2230        endpoint=None,
 2231        healthy=None,
 2232        id=None,
 2233        name=None,
 2234        port_override=None,
 2235        region=None,
 2236        role_arn=None,
 2237        role_external_id=None,
 2238        secret_access_key=None,
 2239        secret_store_id=None,
 2240        tags=None,
 2241    ):
 2242        self.access_key = access_key if access_key is not None else ''
 2243        self.bind_interface = bind_interface if bind_interface is not None else ''
 2244        '''
 2245         Bind interface
 2246        '''
 2247        self.egress_filter = egress_filter if egress_filter is not None else ''
 2248        '''
 2249         A filter applied to the routing logic to pin datasource to nodes.
 2250        '''
 2251        self.endpoint = endpoint if endpoint is not None else ''
 2252        self.healthy = healthy if healthy is not None else False
 2253        '''
 2254         True if the datasource is reachable and the credentials are valid.
 2255        '''
 2256        self.id = id if id is not None else ''
 2257        '''
 2258         Unique identifier of the Resource.
 2259        '''
 2260        self.name = name if name is not None else ''
 2261        '''
 2262         Unique human-readable name of the Resource.
 2263        '''
 2264        self.port_override = port_override if port_override is not None else 0
 2265        self.region = region if region is not None else ''
 2266        self.role_arn = role_arn if role_arn is not None else ''
 2267        self.role_external_id = role_external_id if role_external_id is not None else ''
 2268        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2270        '''
 2271         ID of the secret store containing credentials for this resource, if any.
 2272        '''
 2273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2274        '''
 2275         Tags is a map of key, value pairs.
 2276        '''
 2277
 2278    def __repr__(self):
 2279        return '<sdm.AmazonES ' + \
 2280            'access_key: ' + repr(self.access_key) + ' ' +\
 2281            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2282            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2283            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2284            'healthy: ' + repr(self.healthy) + ' ' +\
 2285            'id: ' + repr(self.id) + ' ' +\
 2286            'name: ' + repr(self.name) + ' ' +\
 2287            'port_override: ' + repr(self.port_override) + ' ' +\
 2288            'region: ' + repr(self.region) + ' ' +\
 2289            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2290            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2291            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2292            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2293            'tags: ' + repr(self.tags) + ' ' +\
 2294            '>'
 2295
 2296    def to_dict(self):
 2297        return {
 2298            'access_key': self.access_key,
 2299            'bind_interface': self.bind_interface,
 2300            'egress_filter': self.egress_filter,
 2301            'endpoint': self.endpoint,
 2302            'healthy': self.healthy,
 2303            'id': self.id,
 2304            'name': self.name,
 2305            'port_override': self.port_override,
 2306            'region': self.region,
 2307            'role_arn': self.role_arn,
 2308            'role_external_id': self.role_external_id,
 2309            'secret_access_key': self.secret_access_key,
 2310            'secret_store_id': self.secret_store_id,
 2311            'tags': self.tags,
 2312        }
 2313
 2314    @classmethod
 2315    def from_dict(cls, d):
 2316        return cls(
 2317            access_key=d.get('access_key'),
 2318            bind_interface=d.get('bind_interface'),
 2319            egress_filter=d.get('egress_filter'),
 2320            endpoint=d.get('endpoint'),
 2321            healthy=d.get('healthy'),
 2322            id=d.get('id'),
 2323            name=d.get('name'),
 2324            port_override=d.get('port_override'),
 2325            region=d.get('region'),
 2326            role_arn=d.get('role_arn'),
 2327            role_external_id=d.get('role_external_id'),
 2328            secret_access_key=d.get('secret_access_key'),
 2329            secret_store_id=d.get('secret_store_id'),
 2330            tags=d.get('tags'),
 2331        )
 2332
 2333
 2334class AmazonMQAMQP091:
 2335    __slots__ = [
 2336        'bind_interface',
 2337        'egress_filter',
 2338        'healthy',
 2339        'hostname',
 2340        'id',
 2341        'name',
 2342        'password',
 2343        'port',
 2344        'port_override',
 2345        'secret_store_id',
 2346        'tags',
 2347        'tls_required',
 2348        'username',
 2349    ]
 2350
 2351    def __init__(
 2352        self,
 2353        bind_interface=None,
 2354        egress_filter=None,
 2355        healthy=None,
 2356        hostname=None,
 2357        id=None,
 2358        name=None,
 2359        password=None,
 2360        port=None,
 2361        port_override=None,
 2362        secret_store_id=None,
 2363        tags=None,
 2364        tls_required=None,
 2365        username=None,
 2366    ):
 2367        self.bind_interface = bind_interface if bind_interface is not None else ''
 2368        '''
 2369         Bind interface
 2370        '''
 2371        self.egress_filter = egress_filter if egress_filter is not None else ''
 2372        '''
 2373         A filter applied to the routing logic to pin datasource to nodes.
 2374        '''
 2375        self.healthy = healthy if healthy is not None else False
 2376        '''
 2377         True if the datasource is reachable and the credentials are valid.
 2378        '''
 2379        self.hostname = hostname if hostname is not None else ''
 2380        self.id = id if id is not None else ''
 2381        '''
 2382         Unique identifier of the Resource.
 2383        '''
 2384        self.name = name if name is not None else ''
 2385        '''
 2386         Unique human-readable name of the Resource.
 2387        '''
 2388        self.password = password if password is not None else ''
 2389        self.port = port if port is not None else 0
 2390        self.port_override = port_override if port_override is not None else 0
 2391        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2392        '''
 2393         ID of the secret store containing credentials for this resource, if any.
 2394        '''
 2395        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2396        '''
 2397         Tags is a map of key, value pairs.
 2398        '''
 2399        self.tls_required = tls_required if tls_required is not None else False
 2400        self.username = username if username is not None else ''
 2401
 2402    def __repr__(self):
 2403        return '<sdm.AmazonMQAMQP091 ' + \
 2404            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2405            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2406            'healthy: ' + repr(self.healthy) + ' ' +\
 2407            'hostname: ' + repr(self.hostname) + ' ' +\
 2408            'id: ' + repr(self.id) + ' ' +\
 2409            'name: ' + repr(self.name) + ' ' +\
 2410            'password: ' + repr(self.password) + ' ' +\
 2411            'port: ' + repr(self.port) + ' ' +\
 2412            'port_override: ' + repr(self.port_override) + ' ' +\
 2413            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2414            'tags: ' + repr(self.tags) + ' ' +\
 2415            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2416            'username: ' + repr(self.username) + ' ' +\
 2417            '>'
 2418
 2419    def to_dict(self):
 2420        return {
 2421            'bind_interface': self.bind_interface,
 2422            'egress_filter': self.egress_filter,
 2423            'healthy': self.healthy,
 2424            'hostname': self.hostname,
 2425            'id': self.id,
 2426            'name': self.name,
 2427            'password': self.password,
 2428            'port': self.port,
 2429            'port_override': self.port_override,
 2430            'secret_store_id': self.secret_store_id,
 2431            'tags': self.tags,
 2432            'tls_required': self.tls_required,
 2433            'username': self.username,
 2434        }
 2435
 2436    @classmethod
 2437    def from_dict(cls, d):
 2438        return cls(
 2439            bind_interface=d.get('bind_interface'),
 2440            egress_filter=d.get('egress_filter'),
 2441            healthy=d.get('healthy'),
 2442            hostname=d.get('hostname'),
 2443            id=d.get('id'),
 2444            name=d.get('name'),
 2445            password=d.get('password'),
 2446            port=d.get('port'),
 2447            port_override=d.get('port_override'),
 2448            secret_store_id=d.get('secret_store_id'),
 2449            tags=d.get('tags'),
 2450            tls_required=d.get('tls_required'),
 2451            username=d.get('username'),
 2452        )
 2453
 2454
 2455class Athena:
 2456    __slots__ = [
 2457        'access_key',
 2458        'bind_interface',
 2459        'egress_filter',
 2460        'healthy',
 2461        'id',
 2462        'name',
 2463        'output',
 2464        'port_override',
 2465        'region',
 2466        'role_arn',
 2467        'role_external_id',
 2468        'secret_access_key',
 2469        'secret_store_id',
 2470        'tags',
 2471    ]
 2472
 2473    def __init__(
 2474        self,
 2475        access_key=None,
 2476        bind_interface=None,
 2477        egress_filter=None,
 2478        healthy=None,
 2479        id=None,
 2480        name=None,
 2481        output=None,
 2482        port_override=None,
 2483        region=None,
 2484        role_arn=None,
 2485        role_external_id=None,
 2486        secret_access_key=None,
 2487        secret_store_id=None,
 2488        tags=None,
 2489    ):
 2490        self.access_key = access_key if access_key is not None else ''
 2491        self.bind_interface = bind_interface if bind_interface is not None else ''
 2492        '''
 2493         Bind interface
 2494        '''
 2495        self.egress_filter = egress_filter if egress_filter is not None else ''
 2496        '''
 2497         A filter applied to the routing logic to pin datasource to nodes.
 2498        '''
 2499        self.healthy = healthy if healthy is not None else False
 2500        '''
 2501         True if the datasource is reachable and the credentials are valid.
 2502        '''
 2503        self.id = id if id is not None else ''
 2504        '''
 2505         Unique identifier of the Resource.
 2506        '''
 2507        self.name = name if name is not None else ''
 2508        '''
 2509         Unique human-readable name of the Resource.
 2510        '''
 2511        self.output = output if output is not None else ''
 2512        self.port_override = port_override if port_override is not None else 0
 2513        self.region = region if region is not None else ''
 2514        self.role_arn = role_arn if role_arn is not None else ''
 2515        self.role_external_id = role_external_id if role_external_id is not None else ''
 2516        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2517        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2518        '''
 2519         ID of the secret store containing credentials for this resource, if any.
 2520        '''
 2521        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2522        '''
 2523         Tags is a map of key, value pairs.
 2524        '''
 2525
 2526    def __repr__(self):
 2527        return '<sdm.Athena ' + \
 2528            'access_key: ' + repr(self.access_key) + ' ' +\
 2529            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2530            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2531            'healthy: ' + repr(self.healthy) + ' ' +\
 2532            'id: ' + repr(self.id) + ' ' +\
 2533            'name: ' + repr(self.name) + ' ' +\
 2534            'output: ' + repr(self.output) + ' ' +\
 2535            'port_override: ' + repr(self.port_override) + ' ' +\
 2536            'region: ' + repr(self.region) + ' ' +\
 2537            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2538            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2539            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2540            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2541            'tags: ' + repr(self.tags) + ' ' +\
 2542            '>'
 2543
 2544    def to_dict(self):
 2545        return {
 2546            'access_key': self.access_key,
 2547            'bind_interface': self.bind_interface,
 2548            'egress_filter': self.egress_filter,
 2549            'healthy': self.healthy,
 2550            'id': self.id,
 2551            'name': self.name,
 2552            'output': self.output,
 2553            'port_override': self.port_override,
 2554            'region': self.region,
 2555            'role_arn': self.role_arn,
 2556            'role_external_id': self.role_external_id,
 2557            'secret_access_key': self.secret_access_key,
 2558            'secret_store_id': self.secret_store_id,
 2559            'tags': self.tags,
 2560        }
 2561
 2562    @classmethod
 2563    def from_dict(cls, d):
 2564        return cls(
 2565            access_key=d.get('access_key'),
 2566            bind_interface=d.get('bind_interface'),
 2567            egress_filter=d.get('egress_filter'),
 2568            healthy=d.get('healthy'),
 2569            id=d.get('id'),
 2570            name=d.get('name'),
 2571            output=d.get('output'),
 2572            port_override=d.get('port_override'),
 2573            region=d.get('region'),
 2574            role_arn=d.get('role_arn'),
 2575            role_external_id=d.get('role_external_id'),
 2576            secret_access_key=d.get('secret_access_key'),
 2577            secret_store_id=d.get('secret_store_id'),
 2578            tags=d.get('tags'),
 2579        )
 2580
 2581
 2582class AuroraMysql:
 2583    __slots__ = [
 2584        'bind_interface',
 2585        'database',
 2586        'egress_filter',
 2587        'healthy',
 2588        'hostname',
 2589        'id',
 2590        'name',
 2591        'password',
 2592        'port',
 2593        'port_override',
 2594        'secret_store_id',
 2595        'tags',
 2596        'username',
 2597    ]
 2598
 2599    def __init__(
 2600        self,
 2601        bind_interface=None,
 2602        database=None,
 2603        egress_filter=None,
 2604        healthy=None,
 2605        hostname=None,
 2606        id=None,
 2607        name=None,
 2608        password=None,
 2609        port=None,
 2610        port_override=None,
 2611        secret_store_id=None,
 2612        tags=None,
 2613        username=None,
 2614    ):
 2615        self.bind_interface = bind_interface if bind_interface is not None else ''
 2616        '''
 2617         Bind interface
 2618        '''
 2619        self.database = database if database is not None else ''
 2620        self.egress_filter = egress_filter if egress_filter is not None else ''
 2621        '''
 2622         A filter applied to the routing logic to pin datasource to nodes.
 2623        '''
 2624        self.healthy = healthy if healthy is not None else False
 2625        '''
 2626         True if the datasource is reachable and the credentials are valid.
 2627        '''
 2628        self.hostname = hostname if hostname is not None else ''
 2629        self.id = id if id is not None else ''
 2630        '''
 2631         Unique identifier of the Resource.
 2632        '''
 2633        self.name = name if name is not None else ''
 2634        '''
 2635         Unique human-readable name of the Resource.
 2636        '''
 2637        self.password = password if password is not None else ''
 2638        self.port = port if port is not None else 0
 2639        self.port_override = port_override if port_override is not None else 0
 2640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2641        '''
 2642         ID of the secret store containing credentials for this resource, if any.
 2643        '''
 2644        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2645        '''
 2646         Tags is a map of key, value pairs.
 2647        '''
 2648        self.username = username if username is not None else ''
 2649
 2650    def __repr__(self):
 2651        return '<sdm.AuroraMysql ' + \
 2652            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2653            'database: ' + repr(self.database) + ' ' +\
 2654            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2655            'healthy: ' + repr(self.healthy) + ' ' +\
 2656            'hostname: ' + repr(self.hostname) + ' ' +\
 2657            'id: ' + repr(self.id) + ' ' +\
 2658            'name: ' + repr(self.name) + ' ' +\
 2659            'password: ' + repr(self.password) + ' ' +\
 2660            'port: ' + repr(self.port) + ' ' +\
 2661            'port_override: ' + repr(self.port_override) + ' ' +\
 2662            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2663            'tags: ' + repr(self.tags) + ' ' +\
 2664            'username: ' + repr(self.username) + ' ' +\
 2665            '>'
 2666
 2667    def to_dict(self):
 2668        return {
 2669            'bind_interface': self.bind_interface,
 2670            'database': self.database,
 2671            'egress_filter': self.egress_filter,
 2672            'healthy': self.healthy,
 2673            'hostname': self.hostname,
 2674            'id': self.id,
 2675            'name': self.name,
 2676            'password': self.password,
 2677            'port': self.port,
 2678            'port_override': self.port_override,
 2679            'secret_store_id': self.secret_store_id,
 2680            'tags': self.tags,
 2681            'username': self.username,
 2682        }
 2683
 2684    @classmethod
 2685    def from_dict(cls, d):
 2686        return cls(
 2687            bind_interface=d.get('bind_interface'),
 2688            database=d.get('database'),
 2689            egress_filter=d.get('egress_filter'),
 2690            healthy=d.get('healthy'),
 2691            hostname=d.get('hostname'),
 2692            id=d.get('id'),
 2693            name=d.get('name'),
 2694            password=d.get('password'),
 2695            port=d.get('port'),
 2696            port_override=d.get('port_override'),
 2697            secret_store_id=d.get('secret_store_id'),
 2698            tags=d.get('tags'),
 2699            username=d.get('username'),
 2700        )
 2701
 2702
 2703class AuroraPostgres:
 2704    __slots__ = [
 2705        'bind_interface',
 2706        'database',
 2707        'egress_filter',
 2708        'healthy',
 2709        'hostname',
 2710        'id',
 2711        'name',
 2712        'override_database',
 2713        'password',
 2714        'port',
 2715        'port_override',
 2716        'secret_store_id',
 2717        'tags',
 2718        'username',
 2719    ]
 2720
 2721    def __init__(
 2722        self,
 2723        bind_interface=None,
 2724        database=None,
 2725        egress_filter=None,
 2726        healthy=None,
 2727        hostname=None,
 2728        id=None,
 2729        name=None,
 2730        override_database=None,
 2731        password=None,
 2732        port=None,
 2733        port_override=None,
 2734        secret_store_id=None,
 2735        tags=None,
 2736        username=None,
 2737    ):
 2738        self.bind_interface = bind_interface if bind_interface is not None else ''
 2739        '''
 2740         Bind interface
 2741        '''
 2742        self.database = database if database is not None else ''
 2743        self.egress_filter = egress_filter if egress_filter is not None else ''
 2744        '''
 2745         A filter applied to the routing logic to pin datasource to nodes.
 2746        '''
 2747        self.healthy = healthy if healthy is not None else False
 2748        '''
 2749         True if the datasource is reachable and the credentials are valid.
 2750        '''
 2751        self.hostname = hostname if hostname is not None else ''
 2752        self.id = id if id is not None else ''
 2753        '''
 2754         Unique identifier of the Resource.
 2755        '''
 2756        self.name = name if name is not None else ''
 2757        '''
 2758         Unique human-readable name of the Resource.
 2759        '''
 2760        self.override_database = override_database if override_database is not None else False
 2761        self.password = password if password is not None else ''
 2762        self.port = port if port is not None else 0
 2763        self.port_override = port_override if port_override is not None else 0
 2764        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2765        '''
 2766         ID of the secret store containing credentials for this resource, if any.
 2767        '''
 2768        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2769        '''
 2770         Tags is a map of key, value pairs.
 2771        '''
 2772        self.username = username if username is not None else ''
 2773
 2774    def __repr__(self):
 2775        return '<sdm.AuroraPostgres ' + \
 2776            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2777            'database: ' + repr(self.database) + ' ' +\
 2778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2779            'healthy: ' + repr(self.healthy) + ' ' +\
 2780            'hostname: ' + repr(self.hostname) + ' ' +\
 2781            'id: ' + repr(self.id) + ' ' +\
 2782            'name: ' + repr(self.name) + ' ' +\
 2783            'override_database: ' + repr(self.override_database) + ' ' +\
 2784            'password: ' + repr(self.password) + ' ' +\
 2785            'port: ' + repr(self.port) + ' ' +\
 2786            'port_override: ' + repr(self.port_override) + ' ' +\
 2787            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2788            'tags: ' + repr(self.tags) + ' ' +\
 2789            'username: ' + repr(self.username) + ' ' +\
 2790            '>'
 2791
 2792    def to_dict(self):
 2793        return {
 2794            'bind_interface': self.bind_interface,
 2795            'database': self.database,
 2796            'egress_filter': self.egress_filter,
 2797            'healthy': self.healthy,
 2798            'hostname': self.hostname,
 2799            'id': self.id,
 2800            'name': self.name,
 2801            'override_database': self.override_database,
 2802            'password': self.password,
 2803            'port': self.port,
 2804            'port_override': self.port_override,
 2805            'secret_store_id': self.secret_store_id,
 2806            'tags': self.tags,
 2807            'username': self.username,
 2808        }
 2809
 2810    @classmethod
 2811    def from_dict(cls, d):
 2812        return cls(
 2813            bind_interface=d.get('bind_interface'),
 2814            database=d.get('database'),
 2815            egress_filter=d.get('egress_filter'),
 2816            healthy=d.get('healthy'),
 2817            hostname=d.get('hostname'),
 2818            id=d.get('id'),
 2819            name=d.get('name'),
 2820            override_database=d.get('override_database'),
 2821            password=d.get('password'),
 2822            port=d.get('port'),
 2823            port_override=d.get('port_override'),
 2824            secret_store_id=d.get('secret_store_id'),
 2825            tags=d.get('tags'),
 2826            username=d.get('username'),
 2827        )
 2828
 2829
 2830class Azure:
 2831    __slots__ = [
 2832        'app_id',
 2833        'bind_interface',
 2834        'egress_filter',
 2835        'healthy',
 2836        'id',
 2837        'name',
 2838        'password',
 2839        'secret_store_id',
 2840        'tags',
 2841        'tenant_id',
 2842    ]
 2843
 2844    def __init__(
 2845        self,
 2846        app_id=None,
 2847        bind_interface=None,
 2848        egress_filter=None,
 2849        healthy=None,
 2850        id=None,
 2851        name=None,
 2852        password=None,
 2853        secret_store_id=None,
 2854        tags=None,
 2855        tenant_id=None,
 2856    ):
 2857        self.app_id = app_id if app_id is not None else ''
 2858        self.bind_interface = bind_interface if bind_interface is not None else ''
 2859        '''
 2860         Bind interface
 2861        '''
 2862        self.egress_filter = egress_filter if egress_filter is not None else ''
 2863        '''
 2864         A filter applied to the routing logic to pin datasource to nodes.
 2865        '''
 2866        self.healthy = healthy if healthy is not None else False
 2867        '''
 2868         True if the datasource is reachable and the credentials are valid.
 2869        '''
 2870        self.id = id if id is not None else ''
 2871        '''
 2872         Unique identifier of the Resource.
 2873        '''
 2874        self.name = name if name is not None else ''
 2875        '''
 2876         Unique human-readable name of the Resource.
 2877        '''
 2878        self.password = password if password is not None else ''
 2879        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2880        '''
 2881         ID of the secret store containing credentials for this resource, if any.
 2882        '''
 2883        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2884        '''
 2885         Tags is a map of key, value pairs.
 2886        '''
 2887        self.tenant_id = tenant_id if tenant_id is not None else ''
 2888
 2889    def __repr__(self):
 2890        return '<sdm.Azure ' + \
 2891            'app_id: ' + repr(self.app_id) + ' ' +\
 2892            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2893            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2894            'healthy: ' + repr(self.healthy) + ' ' +\
 2895            'id: ' + repr(self.id) + ' ' +\
 2896            'name: ' + repr(self.name) + ' ' +\
 2897            'password: ' + repr(self.password) + ' ' +\
 2898            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2899            'tags: ' + repr(self.tags) + ' ' +\
 2900            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2901            '>'
 2902
 2903    def to_dict(self):
 2904        return {
 2905            'app_id': self.app_id,
 2906            'bind_interface': self.bind_interface,
 2907            'egress_filter': self.egress_filter,
 2908            'healthy': self.healthy,
 2909            'id': self.id,
 2910            'name': self.name,
 2911            'password': self.password,
 2912            'secret_store_id': self.secret_store_id,
 2913            'tags': self.tags,
 2914            'tenant_id': self.tenant_id,
 2915        }
 2916
 2917    @classmethod
 2918    def from_dict(cls, d):
 2919        return cls(
 2920            app_id=d.get('app_id'),
 2921            bind_interface=d.get('bind_interface'),
 2922            egress_filter=d.get('egress_filter'),
 2923            healthy=d.get('healthy'),
 2924            id=d.get('id'),
 2925            name=d.get('name'),
 2926            password=d.get('password'),
 2927            secret_store_id=d.get('secret_store_id'),
 2928            tags=d.get('tags'),
 2929            tenant_id=d.get('tenant_id'),
 2930        )
 2931
 2932
 2933class AzureCertificate:
 2934    __slots__ = [
 2935        'app_id',
 2936        'bind_interface',
 2937        'client_certificate',
 2938        'egress_filter',
 2939        'healthy',
 2940        'id',
 2941        'name',
 2942        'secret_store_id',
 2943        'tags',
 2944        'tenant_id',
 2945    ]
 2946
 2947    def __init__(
 2948        self,
 2949        app_id=None,
 2950        bind_interface=None,
 2951        client_certificate=None,
 2952        egress_filter=None,
 2953        healthy=None,
 2954        id=None,
 2955        name=None,
 2956        secret_store_id=None,
 2957        tags=None,
 2958        tenant_id=None,
 2959    ):
 2960        self.app_id = app_id if app_id is not None else ''
 2961        self.bind_interface = bind_interface if bind_interface is not None else ''
 2962        '''
 2963         Bind interface
 2964        '''
 2965        self.client_certificate = client_certificate if client_certificate is not None else ''
 2966        self.egress_filter = egress_filter if egress_filter is not None else ''
 2967        '''
 2968         A filter applied to the routing logic to pin datasource to nodes.
 2969        '''
 2970        self.healthy = healthy if healthy is not None else False
 2971        '''
 2972         True if the datasource is reachable and the credentials are valid.
 2973        '''
 2974        self.id = id if id is not None else ''
 2975        '''
 2976         Unique identifier of the Resource.
 2977        '''
 2978        self.name = name if name is not None else ''
 2979        '''
 2980         Unique human-readable name of the Resource.
 2981        '''
 2982        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2983        '''
 2984         ID of the secret store containing credentials for this resource, if any.
 2985        '''
 2986        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2987        '''
 2988         Tags is a map of key, value pairs.
 2989        '''
 2990        self.tenant_id = tenant_id if tenant_id is not None else ''
 2991
 2992    def __repr__(self):
 2993        return '<sdm.AzureCertificate ' + \
 2994            'app_id: ' + repr(self.app_id) + ' ' +\
 2995            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2996            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2997            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2998            'healthy: ' + repr(self.healthy) + ' ' +\
 2999            'id: ' + repr(self.id) + ' ' +\
 3000            'name: ' + repr(self.name) + ' ' +\
 3001            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3002            'tags: ' + repr(self.tags) + ' ' +\
 3003            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 3004            '>'
 3005
 3006    def to_dict(self):
 3007        return {
 3008            'app_id': self.app_id,
 3009            'bind_interface': self.bind_interface,
 3010            'client_certificate': self.client_certificate,
 3011            'egress_filter': self.egress_filter,
 3012            'healthy': self.healthy,
 3013            'id': self.id,
 3014            'name': self.name,
 3015            'secret_store_id': self.secret_store_id,
 3016            'tags': self.tags,
 3017            'tenant_id': self.tenant_id,
 3018        }
 3019
 3020    @classmethod
 3021    def from_dict(cls, d):
 3022        return cls(
 3023            app_id=d.get('app_id'),
 3024            bind_interface=d.get('bind_interface'),
 3025            client_certificate=d.get('client_certificate'),
 3026            egress_filter=d.get('egress_filter'),
 3027            healthy=d.get('healthy'),
 3028            id=d.get('id'),
 3029            name=d.get('name'),
 3030            secret_store_id=d.get('secret_store_id'),
 3031            tags=d.get('tags'),
 3032            tenant_id=d.get('tenant_id'),
 3033        )
 3034
 3035
 3036class AzureMysql:
 3037    '''
 3038    AzureMysql is currently unstable, and its API may change, or it may be removed,
 3039    without a major version bump.
 3040    '''
 3041    __slots__ = [
 3042        'bind_interface',
 3043        'database',
 3044        'egress_filter',
 3045        'healthy',
 3046        'hostname',
 3047        'id',
 3048        'name',
 3049        'password',
 3050        'port',
 3051        'port_override',
 3052        'secret_store_id',
 3053        'tags',
 3054        'username',
 3055    ]
 3056
 3057    def __init__(
 3058        self,
 3059        bind_interface=None,
 3060        database=None,
 3061        egress_filter=None,
 3062        healthy=None,
 3063        hostname=None,
 3064        id=None,
 3065        name=None,
 3066        password=None,
 3067        port=None,
 3068        port_override=None,
 3069        secret_store_id=None,
 3070        tags=None,
 3071        username=None,
 3072    ):
 3073        self.bind_interface = bind_interface if bind_interface is not None else ''
 3074        '''
 3075         Bind interface
 3076        '''
 3077        self.database = database if database is not None else ''
 3078        self.egress_filter = egress_filter if egress_filter is not None else ''
 3079        '''
 3080         A filter applied to the routing logic to pin datasource to nodes.
 3081        '''
 3082        self.healthy = healthy if healthy is not None else False
 3083        '''
 3084         True if the datasource is reachable and the credentials are valid.
 3085        '''
 3086        self.hostname = hostname if hostname is not None else ''
 3087        self.id = id if id is not None else ''
 3088        '''
 3089         Unique identifier of the Resource.
 3090        '''
 3091        self.name = name if name is not None else ''
 3092        '''
 3093         Unique human-readable name of the Resource.
 3094        '''
 3095        self.password = password if password is not None else ''
 3096        self.port = port if port is not None else 0
 3097        self.port_override = port_override if port_override is not None else 0
 3098        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3099        '''
 3100         ID of the secret store containing credentials for this resource, if any.
 3101        '''
 3102        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3103        '''
 3104         Tags is a map of key, value pairs.
 3105        '''
 3106        self.username = username if username is not None else ''
 3107
 3108    def __repr__(self):
 3109        return '<sdm.AzureMysql ' + \
 3110            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3111            'database: ' + repr(self.database) + ' ' +\
 3112            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3113            'healthy: ' + repr(self.healthy) + ' ' +\
 3114            'hostname: ' + repr(self.hostname) + ' ' +\
 3115            'id: ' + repr(self.id) + ' ' +\
 3116            'name: ' + repr(self.name) + ' ' +\
 3117            'password: ' + repr(self.password) + ' ' +\
 3118            'port: ' + repr(self.port) + ' ' +\
 3119            'port_override: ' + repr(self.port_override) + ' ' +\
 3120            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3121            'tags: ' + repr(self.tags) + ' ' +\
 3122            'username: ' + repr(self.username) + ' ' +\
 3123            '>'
 3124
 3125    def to_dict(self):
 3126        return {
 3127            'bind_interface': self.bind_interface,
 3128            'database': self.database,
 3129            'egress_filter': self.egress_filter,
 3130            'healthy': self.healthy,
 3131            'hostname': self.hostname,
 3132            'id': self.id,
 3133            'name': self.name,
 3134            'password': self.password,
 3135            'port': self.port,
 3136            'port_override': self.port_override,
 3137            'secret_store_id': self.secret_store_id,
 3138            'tags': self.tags,
 3139            'username': self.username,
 3140        }
 3141
 3142    @classmethod
 3143    def from_dict(cls, d):
 3144        return cls(
 3145            bind_interface=d.get('bind_interface'),
 3146            database=d.get('database'),
 3147            egress_filter=d.get('egress_filter'),
 3148            healthy=d.get('healthy'),
 3149            hostname=d.get('hostname'),
 3150            id=d.get('id'),
 3151            name=d.get('name'),
 3152            password=d.get('password'),
 3153            port=d.get('port'),
 3154            port_override=d.get('port_override'),
 3155            secret_store_id=d.get('secret_store_id'),
 3156            tags=d.get('tags'),
 3157            username=d.get('username'),
 3158        )
 3159
 3160
 3161class AzurePostgres:
 3162    __slots__ = [
 3163        'bind_interface',
 3164        'database',
 3165        'egress_filter',
 3166        'healthy',
 3167        'hostname',
 3168        'id',
 3169        'name',
 3170        'override_database',
 3171        'password',
 3172        'port',
 3173        'port_override',
 3174        'secret_store_id',
 3175        'tags',
 3176        'username',
 3177    ]
 3178
 3179    def __init__(
 3180        self,
 3181        bind_interface=None,
 3182        database=None,
 3183        egress_filter=None,
 3184        healthy=None,
 3185        hostname=None,
 3186        id=None,
 3187        name=None,
 3188        override_database=None,
 3189        password=None,
 3190        port=None,
 3191        port_override=None,
 3192        secret_store_id=None,
 3193        tags=None,
 3194        username=None,
 3195    ):
 3196        self.bind_interface = bind_interface if bind_interface is not None else ''
 3197        '''
 3198         Bind interface
 3199        '''
 3200        self.database = database if database is not None else ''
 3201        self.egress_filter = egress_filter if egress_filter is not None else ''
 3202        '''
 3203         A filter applied to the routing logic to pin datasource to nodes.
 3204        '''
 3205        self.healthy = healthy if healthy is not None else False
 3206        '''
 3207         True if the datasource is reachable and the credentials are valid.
 3208        '''
 3209        self.hostname = hostname if hostname is not None else ''
 3210        self.id = id if id is not None else ''
 3211        '''
 3212         Unique identifier of the Resource.
 3213        '''
 3214        self.name = name if name is not None else ''
 3215        '''
 3216         Unique human-readable name of the Resource.
 3217        '''
 3218        self.override_database = override_database if override_database is not None else False
 3219        self.password = password if password is not None else ''
 3220        self.port = port if port is not None else 0
 3221        self.port_override = port_override if port_override is not None else 0
 3222        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3223        '''
 3224         ID of the secret store containing credentials for this resource, if any.
 3225        '''
 3226        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3227        '''
 3228         Tags is a map of key, value pairs.
 3229        '''
 3230        self.username = username if username is not None else ''
 3231
 3232    def __repr__(self):
 3233        return '<sdm.AzurePostgres ' + \
 3234            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3235            'database: ' + repr(self.database) + ' ' +\
 3236            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3237            'healthy: ' + repr(self.healthy) + ' ' +\
 3238            'hostname: ' + repr(self.hostname) + ' ' +\
 3239            'id: ' + repr(self.id) + ' ' +\
 3240            'name: ' + repr(self.name) + ' ' +\
 3241            'override_database: ' + repr(self.override_database) + ' ' +\
 3242            'password: ' + repr(self.password) + ' ' +\
 3243            'port: ' + repr(self.port) + ' ' +\
 3244            'port_override: ' + repr(self.port_override) + ' ' +\
 3245            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3246            'tags: ' + repr(self.tags) + ' ' +\
 3247            'username: ' + repr(self.username) + ' ' +\
 3248            '>'
 3249
 3250    def to_dict(self):
 3251        return {
 3252            'bind_interface': self.bind_interface,
 3253            'database': self.database,
 3254            'egress_filter': self.egress_filter,
 3255            'healthy': self.healthy,
 3256            'hostname': self.hostname,
 3257            'id': self.id,
 3258            'name': self.name,
 3259            'override_database': self.override_database,
 3260            'password': self.password,
 3261            'port': self.port,
 3262            'port_override': self.port_override,
 3263            'secret_store_id': self.secret_store_id,
 3264            'tags': self.tags,
 3265            'username': self.username,
 3266        }
 3267
 3268    @classmethod
 3269    def from_dict(cls, d):
 3270        return cls(
 3271            bind_interface=d.get('bind_interface'),
 3272            database=d.get('database'),
 3273            egress_filter=d.get('egress_filter'),
 3274            healthy=d.get('healthy'),
 3275            hostname=d.get('hostname'),
 3276            id=d.get('id'),
 3277            name=d.get('name'),
 3278            override_database=d.get('override_database'),
 3279            password=d.get('password'),
 3280            port=d.get('port'),
 3281            port_override=d.get('port_override'),
 3282            secret_store_id=d.get('secret_store_id'),
 3283            tags=d.get('tags'),
 3284            username=d.get('username'),
 3285        )
 3286
 3287
 3288class AzureStore:
 3289    __slots__ = [
 3290        'id',
 3291        'name',
 3292        'tags',
 3293        'vault_uri',
 3294    ]
 3295
 3296    def __init__(
 3297        self,
 3298        id=None,
 3299        name=None,
 3300        tags=None,
 3301        vault_uri=None,
 3302    ):
 3303        self.id = id if id is not None else ''
 3304        '''
 3305         Unique identifier of the SecretStore.
 3306        '''
 3307        self.name = name if name is not None else ''
 3308        '''
 3309         Unique human-readable name of the SecretStore.
 3310        '''
 3311        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3312        '''
 3313         Tags is a map of key, value pairs.
 3314        '''
 3315        self.vault_uri = vault_uri if vault_uri is not None else ''
 3316
 3317    def __repr__(self):
 3318        return '<sdm.AzureStore ' + \
 3319            'id: ' + repr(self.id) + ' ' +\
 3320            'name: ' + repr(self.name) + ' ' +\
 3321            'tags: ' + repr(self.tags) + ' ' +\
 3322            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3323            '>'
 3324
 3325    def to_dict(self):
 3326        return {
 3327            'id': self.id,
 3328            'name': self.name,
 3329            'tags': self.tags,
 3330            'vault_uri': self.vault_uri,
 3331        }
 3332
 3333    @classmethod
 3334    def from_dict(cls, d):
 3335        return cls(
 3336            id=d.get('id'),
 3337            name=d.get('name'),
 3338            tags=d.get('tags'),
 3339            vault_uri=d.get('vault_uri'),
 3340        )
 3341
 3342
 3343class BigQuery:
 3344    __slots__ = [
 3345        'bind_interface',
 3346        'egress_filter',
 3347        'endpoint',
 3348        'healthy',
 3349        'id',
 3350        'name',
 3351        'port_override',
 3352        'private_key',
 3353        'project',
 3354        'secret_store_id',
 3355        'tags',
 3356        'username',
 3357    ]
 3358
 3359    def __init__(
 3360        self,
 3361        bind_interface=None,
 3362        egress_filter=None,
 3363        endpoint=None,
 3364        healthy=None,
 3365        id=None,
 3366        name=None,
 3367        port_override=None,
 3368        private_key=None,
 3369        project=None,
 3370        secret_store_id=None,
 3371        tags=None,
 3372        username=None,
 3373    ):
 3374        self.bind_interface = bind_interface if bind_interface is not None else ''
 3375        '''
 3376         Bind interface
 3377        '''
 3378        self.egress_filter = egress_filter if egress_filter is not None else ''
 3379        '''
 3380         A filter applied to the routing logic to pin datasource to nodes.
 3381        '''
 3382        self.endpoint = endpoint if endpoint is not None else ''
 3383        self.healthy = healthy if healthy is not None else False
 3384        '''
 3385         True if the datasource is reachable and the credentials are valid.
 3386        '''
 3387        self.id = id if id is not None else ''
 3388        '''
 3389         Unique identifier of the Resource.
 3390        '''
 3391        self.name = name if name is not None else ''
 3392        '''
 3393         Unique human-readable name of the Resource.
 3394        '''
 3395        self.port_override = port_override if port_override is not None else 0
 3396        self.private_key = private_key if private_key is not None else ''
 3397        self.project = project if project is not None else ''
 3398        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3399        '''
 3400         ID of the secret store containing credentials for this resource, if any.
 3401        '''
 3402        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3403        '''
 3404         Tags is a map of key, value pairs.
 3405        '''
 3406        self.username = username if username is not None else ''
 3407
 3408    def __repr__(self):
 3409        return '<sdm.BigQuery ' + \
 3410            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3411            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3412            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3413            'healthy: ' + repr(self.healthy) + ' ' +\
 3414            'id: ' + repr(self.id) + ' ' +\
 3415            'name: ' + repr(self.name) + ' ' +\
 3416            'port_override: ' + repr(self.port_override) + ' ' +\
 3417            'private_key: ' + repr(self.private_key) + ' ' +\
 3418            'project: ' + repr(self.project) + ' ' +\
 3419            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3420            'tags: ' + repr(self.tags) + ' ' +\
 3421            'username: ' + repr(self.username) + ' ' +\
 3422            '>'
 3423
 3424    def to_dict(self):
 3425        return {
 3426            'bind_interface': self.bind_interface,
 3427            'egress_filter': self.egress_filter,
 3428            'endpoint': self.endpoint,
 3429            'healthy': self.healthy,
 3430            'id': self.id,
 3431            'name': self.name,
 3432            'port_override': self.port_override,
 3433            'private_key': self.private_key,
 3434            'project': self.project,
 3435            'secret_store_id': self.secret_store_id,
 3436            'tags': self.tags,
 3437            'username': self.username,
 3438        }
 3439
 3440    @classmethod
 3441    def from_dict(cls, d):
 3442        return cls(
 3443            bind_interface=d.get('bind_interface'),
 3444            egress_filter=d.get('egress_filter'),
 3445            endpoint=d.get('endpoint'),
 3446            healthy=d.get('healthy'),
 3447            id=d.get('id'),
 3448            name=d.get('name'),
 3449            port_override=d.get('port_override'),
 3450            private_key=d.get('private_key'),
 3451            project=d.get('project'),
 3452            secret_store_id=d.get('secret_store_id'),
 3453            tags=d.get('tags'),
 3454            username=d.get('username'),
 3455        )
 3456
 3457
 3458class Cassandra:
 3459    __slots__ = [
 3460        'bind_interface',
 3461        'egress_filter',
 3462        'healthy',
 3463        'hostname',
 3464        'id',
 3465        'name',
 3466        'password',
 3467        'port',
 3468        'port_override',
 3469        'secret_store_id',
 3470        'tags',
 3471        'tls_required',
 3472        'username',
 3473    ]
 3474
 3475    def __init__(
 3476        self,
 3477        bind_interface=None,
 3478        egress_filter=None,
 3479        healthy=None,
 3480        hostname=None,
 3481        id=None,
 3482        name=None,
 3483        password=None,
 3484        port=None,
 3485        port_override=None,
 3486        secret_store_id=None,
 3487        tags=None,
 3488        tls_required=None,
 3489        username=None,
 3490    ):
 3491        self.bind_interface = bind_interface if bind_interface is not None else ''
 3492        '''
 3493         Bind interface
 3494        '''
 3495        self.egress_filter = egress_filter if egress_filter is not None else ''
 3496        '''
 3497         A filter applied to the routing logic to pin datasource to nodes.
 3498        '''
 3499        self.healthy = healthy if healthy is not None else False
 3500        '''
 3501         True if the datasource is reachable and the credentials are valid.
 3502        '''
 3503        self.hostname = hostname if hostname is not None else ''
 3504        self.id = id if id is not None else ''
 3505        '''
 3506         Unique identifier of the Resource.
 3507        '''
 3508        self.name = name if name is not None else ''
 3509        '''
 3510         Unique human-readable name of the Resource.
 3511        '''
 3512        self.password = password if password is not None else ''
 3513        self.port = port if port is not None else 0
 3514        self.port_override = port_override if port_override is not None else 0
 3515        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3516        '''
 3517         ID of the secret store containing credentials for this resource, if any.
 3518        '''
 3519        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3520        '''
 3521         Tags is a map of key, value pairs.
 3522        '''
 3523        self.tls_required = tls_required if tls_required is not None else False
 3524        self.username = username if username is not None else ''
 3525
 3526    def __repr__(self):
 3527        return '<sdm.Cassandra ' + \
 3528            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3529            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3530            'healthy: ' + repr(self.healthy) + ' ' +\
 3531            'hostname: ' + repr(self.hostname) + ' ' +\
 3532            'id: ' + repr(self.id) + ' ' +\
 3533            'name: ' + repr(self.name) + ' ' +\
 3534            'password: ' + repr(self.password) + ' ' +\
 3535            'port: ' + repr(self.port) + ' ' +\
 3536            'port_override: ' + repr(self.port_override) + ' ' +\
 3537            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3538            'tags: ' + repr(self.tags) + ' ' +\
 3539            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3540            'username: ' + repr(self.username) + ' ' +\
 3541            '>'
 3542
 3543    def to_dict(self):
 3544        return {
 3545            'bind_interface': self.bind_interface,
 3546            'egress_filter': self.egress_filter,
 3547            'healthy': self.healthy,
 3548            'hostname': self.hostname,
 3549            'id': self.id,
 3550            'name': self.name,
 3551            'password': self.password,
 3552            'port': self.port,
 3553            'port_override': self.port_override,
 3554            'secret_store_id': self.secret_store_id,
 3555            'tags': self.tags,
 3556            'tls_required': self.tls_required,
 3557            'username': self.username,
 3558        }
 3559
 3560    @classmethod
 3561    def from_dict(cls, d):
 3562        return cls(
 3563            bind_interface=d.get('bind_interface'),
 3564            egress_filter=d.get('egress_filter'),
 3565            healthy=d.get('healthy'),
 3566            hostname=d.get('hostname'),
 3567            id=d.get('id'),
 3568            name=d.get('name'),
 3569            password=d.get('password'),
 3570            port=d.get('port'),
 3571            port_override=d.get('port_override'),
 3572            secret_store_id=d.get('secret_store_id'),
 3573            tags=d.get('tags'),
 3574            tls_required=d.get('tls_required'),
 3575            username=d.get('username'),
 3576        )
 3577
 3578
 3579class Citus:
 3580    __slots__ = [
 3581        'bind_interface',
 3582        'database',
 3583        'egress_filter',
 3584        'healthy',
 3585        'hostname',
 3586        'id',
 3587        'name',
 3588        'override_database',
 3589        'password',
 3590        'port',
 3591        'port_override',
 3592        'secret_store_id',
 3593        'tags',
 3594        'username',
 3595    ]
 3596
 3597    def __init__(
 3598        self,
 3599        bind_interface=None,
 3600        database=None,
 3601        egress_filter=None,
 3602        healthy=None,
 3603        hostname=None,
 3604        id=None,
 3605        name=None,
 3606        override_database=None,
 3607        password=None,
 3608        port=None,
 3609        port_override=None,
 3610        secret_store_id=None,
 3611        tags=None,
 3612        username=None,
 3613    ):
 3614        self.bind_interface = bind_interface if bind_interface is not None else ''
 3615        '''
 3616         Bind interface
 3617        '''
 3618        self.database = database if database is not None else ''
 3619        self.egress_filter = egress_filter if egress_filter is not None else ''
 3620        '''
 3621         A filter applied to the routing logic to pin datasource to nodes.
 3622        '''
 3623        self.healthy = healthy if healthy is not None else False
 3624        '''
 3625         True if the datasource is reachable and the credentials are valid.
 3626        '''
 3627        self.hostname = hostname if hostname is not None else ''
 3628        self.id = id if id is not None else ''
 3629        '''
 3630         Unique identifier of the Resource.
 3631        '''
 3632        self.name = name if name is not None else ''
 3633        '''
 3634         Unique human-readable name of the Resource.
 3635        '''
 3636        self.override_database = override_database if override_database is not None else False
 3637        self.password = password if password is not None else ''
 3638        self.port = port if port is not None else 0
 3639        self.port_override = port_override if port_override is not None else 0
 3640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3641        '''
 3642         ID of the secret store containing credentials for this resource, if any.
 3643        '''
 3644        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3645        '''
 3646         Tags is a map of key, value pairs.
 3647        '''
 3648        self.username = username if username is not None else ''
 3649
 3650    def __repr__(self):
 3651        return '<sdm.Citus ' + \
 3652            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3653            'database: ' + repr(self.database) + ' ' +\
 3654            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3655            'healthy: ' + repr(self.healthy) + ' ' +\
 3656            'hostname: ' + repr(self.hostname) + ' ' +\
 3657            'id: ' + repr(self.id) + ' ' +\
 3658            'name: ' + repr(self.name) + ' ' +\
 3659            'override_database: ' + repr(self.override_database) + ' ' +\
 3660            'password: ' + repr(self.password) + ' ' +\
 3661            'port: ' + repr(self.port) + ' ' +\
 3662            'port_override: ' + repr(self.port_override) + ' ' +\
 3663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3664            'tags: ' + repr(self.tags) + ' ' +\
 3665            'username: ' + repr(self.username) + ' ' +\
 3666            '>'
 3667
 3668    def to_dict(self):
 3669        return {
 3670            'bind_interface': self.bind_interface,
 3671            'database': self.database,
 3672            'egress_filter': self.egress_filter,
 3673            'healthy': self.healthy,
 3674            'hostname': self.hostname,
 3675            'id': self.id,
 3676            'name': self.name,
 3677            'override_database': self.override_database,
 3678            'password': self.password,
 3679            'port': self.port,
 3680            'port_override': self.port_override,
 3681            'secret_store_id': self.secret_store_id,
 3682            'tags': self.tags,
 3683            'username': self.username,
 3684        }
 3685
 3686    @classmethod
 3687    def from_dict(cls, d):
 3688        return cls(
 3689            bind_interface=d.get('bind_interface'),
 3690            database=d.get('database'),
 3691            egress_filter=d.get('egress_filter'),
 3692            healthy=d.get('healthy'),
 3693            hostname=d.get('hostname'),
 3694            id=d.get('id'),
 3695            name=d.get('name'),
 3696            override_database=d.get('override_database'),
 3697            password=d.get('password'),
 3698            port=d.get('port'),
 3699            port_override=d.get('port_override'),
 3700            secret_store_id=d.get('secret_store_id'),
 3701            tags=d.get('tags'),
 3702            username=d.get('username'),
 3703        )
 3704
 3705
 3706class Clustrix:
 3707    __slots__ = [
 3708        'bind_interface',
 3709        'database',
 3710        'egress_filter',
 3711        'healthy',
 3712        'hostname',
 3713        'id',
 3714        'name',
 3715        'password',
 3716        'port',
 3717        'port_override',
 3718        'secret_store_id',
 3719        'tags',
 3720        'username',
 3721    ]
 3722
 3723    def __init__(
 3724        self,
 3725        bind_interface=None,
 3726        database=None,
 3727        egress_filter=None,
 3728        healthy=None,
 3729        hostname=None,
 3730        id=None,
 3731        name=None,
 3732        password=None,
 3733        port=None,
 3734        port_override=None,
 3735        secret_store_id=None,
 3736        tags=None,
 3737        username=None,
 3738    ):
 3739        self.bind_interface = bind_interface if bind_interface is not None else ''
 3740        '''
 3741         Bind interface
 3742        '''
 3743        self.database = database if database is not None else ''
 3744        self.egress_filter = egress_filter if egress_filter is not None else ''
 3745        '''
 3746         A filter applied to the routing logic to pin datasource to nodes.
 3747        '''
 3748        self.healthy = healthy if healthy is not None else False
 3749        '''
 3750         True if the datasource is reachable and the credentials are valid.
 3751        '''
 3752        self.hostname = hostname if hostname is not None else ''
 3753        self.id = id if id is not None else ''
 3754        '''
 3755         Unique identifier of the Resource.
 3756        '''
 3757        self.name = name if name is not None else ''
 3758        '''
 3759         Unique human-readable name of the Resource.
 3760        '''
 3761        self.password = password if password is not None else ''
 3762        self.port = port if port is not None else 0
 3763        self.port_override = port_override if port_override is not None else 0
 3764        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3765        '''
 3766         ID of the secret store containing credentials for this resource, if any.
 3767        '''
 3768        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3769        '''
 3770         Tags is a map of key, value pairs.
 3771        '''
 3772        self.username = username if username is not None else ''
 3773
 3774    def __repr__(self):
 3775        return '<sdm.Clustrix ' + \
 3776            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3777            'database: ' + repr(self.database) + ' ' +\
 3778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3779            'healthy: ' + repr(self.healthy) + ' ' +\
 3780            'hostname: ' + repr(self.hostname) + ' ' +\
 3781            'id: ' + repr(self.id) + ' ' +\
 3782            'name: ' + repr(self.name) + ' ' +\
 3783            'password: ' + repr(self.password) + ' ' +\
 3784            'port: ' + repr(self.port) + ' ' +\
 3785            'port_override: ' + repr(self.port_override) + ' ' +\
 3786            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3787            'tags: ' + repr(self.tags) + ' ' +\
 3788            'username: ' + repr(self.username) + ' ' +\
 3789            '>'
 3790
 3791    def to_dict(self):
 3792        return {
 3793            'bind_interface': self.bind_interface,
 3794            'database': self.database,
 3795            'egress_filter': self.egress_filter,
 3796            'healthy': self.healthy,
 3797            'hostname': self.hostname,
 3798            'id': self.id,
 3799            'name': self.name,
 3800            'password': self.password,
 3801            'port': self.port,
 3802            'port_override': self.port_override,
 3803            'secret_store_id': self.secret_store_id,
 3804            'tags': self.tags,
 3805            'username': self.username,
 3806        }
 3807
 3808    @classmethod
 3809    def from_dict(cls, d):
 3810        return cls(
 3811            bind_interface=d.get('bind_interface'),
 3812            database=d.get('database'),
 3813            egress_filter=d.get('egress_filter'),
 3814            healthy=d.get('healthy'),
 3815            hostname=d.get('hostname'),
 3816            id=d.get('id'),
 3817            name=d.get('name'),
 3818            password=d.get('password'),
 3819            port=d.get('port'),
 3820            port_override=d.get('port_override'),
 3821            secret_store_id=d.get('secret_store_id'),
 3822            tags=d.get('tags'),
 3823            username=d.get('username'),
 3824        )
 3825
 3826
 3827class Cockroach:
 3828    __slots__ = [
 3829        'bind_interface',
 3830        'database',
 3831        'egress_filter',
 3832        'healthy',
 3833        'hostname',
 3834        'id',
 3835        'name',
 3836        'override_database',
 3837        'password',
 3838        'port',
 3839        'port_override',
 3840        'secret_store_id',
 3841        'tags',
 3842        'username',
 3843    ]
 3844
 3845    def __init__(
 3846        self,
 3847        bind_interface=None,
 3848        database=None,
 3849        egress_filter=None,
 3850        healthy=None,
 3851        hostname=None,
 3852        id=None,
 3853        name=None,
 3854        override_database=None,
 3855        password=None,
 3856        port=None,
 3857        port_override=None,
 3858        secret_store_id=None,
 3859        tags=None,
 3860        username=None,
 3861    ):
 3862        self.bind_interface = bind_interface if bind_interface is not None else ''
 3863        '''
 3864         Bind interface
 3865        '''
 3866        self.database = database if database is not None else ''
 3867        self.egress_filter = egress_filter if egress_filter is not None else ''
 3868        '''
 3869         A filter applied to the routing logic to pin datasource to nodes.
 3870        '''
 3871        self.healthy = healthy if healthy is not None else False
 3872        '''
 3873         True if the datasource is reachable and the credentials are valid.
 3874        '''
 3875        self.hostname = hostname if hostname is not None else ''
 3876        self.id = id if id is not None else ''
 3877        '''
 3878         Unique identifier of the Resource.
 3879        '''
 3880        self.name = name if name is not None else ''
 3881        '''
 3882         Unique human-readable name of the Resource.
 3883        '''
 3884        self.override_database = override_database if override_database is not None else False
 3885        self.password = password if password is not None else ''
 3886        self.port = port if port is not None else 0
 3887        self.port_override = port_override if port_override is not None else 0
 3888        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3889        '''
 3890         ID of the secret store containing credentials for this resource, if any.
 3891        '''
 3892        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3893        '''
 3894         Tags is a map of key, value pairs.
 3895        '''
 3896        self.username = username if username is not None else ''
 3897
 3898    def __repr__(self):
 3899        return '<sdm.Cockroach ' + \
 3900            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3901            'database: ' + repr(self.database) + ' ' +\
 3902            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3903            'healthy: ' + repr(self.healthy) + ' ' +\
 3904            'hostname: ' + repr(self.hostname) + ' ' +\
 3905            'id: ' + repr(self.id) + ' ' +\
 3906            'name: ' + repr(self.name) + ' ' +\
 3907            'override_database: ' + repr(self.override_database) + ' ' +\
 3908            'password: ' + repr(self.password) + ' ' +\
 3909            'port: ' + repr(self.port) + ' ' +\
 3910            'port_override: ' + repr(self.port_override) + ' ' +\
 3911            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3912            'tags: ' + repr(self.tags) + ' ' +\
 3913            'username: ' + repr(self.username) + ' ' +\
 3914            '>'
 3915
 3916    def to_dict(self):
 3917        return {
 3918            'bind_interface': self.bind_interface,
 3919            'database': self.database,
 3920            'egress_filter': self.egress_filter,
 3921            'healthy': self.healthy,
 3922            'hostname': self.hostname,
 3923            'id': self.id,
 3924            'name': self.name,
 3925            'override_database': self.override_database,
 3926            'password': self.password,
 3927            'port': self.port,
 3928            'port_override': self.port_override,
 3929            'secret_store_id': self.secret_store_id,
 3930            'tags': self.tags,
 3931            'username': self.username,
 3932        }
 3933
 3934    @classmethod
 3935    def from_dict(cls, d):
 3936        return cls(
 3937            bind_interface=d.get('bind_interface'),
 3938            database=d.get('database'),
 3939            egress_filter=d.get('egress_filter'),
 3940            healthy=d.get('healthy'),
 3941            hostname=d.get('hostname'),
 3942            id=d.get('id'),
 3943            name=d.get('name'),
 3944            override_database=d.get('override_database'),
 3945            password=d.get('password'),
 3946            port=d.get('port'),
 3947            port_override=d.get('port_override'),
 3948            secret_store_id=d.get('secret_store_id'),
 3949            tags=d.get('tags'),
 3950            username=d.get('username'),
 3951        )
 3952
 3953
 3954class ControlPanelGetSSHCAPublicKeyResponse:
 3955    '''
 3956         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3957     organization's SSH Certificate Authority public key.
 3958    '''
 3959    __slots__ = [
 3960        'meta',
 3961        'public_key',
 3962        'rate_limit',
 3963    ]
 3964
 3965    def __init__(
 3966        self,
 3967        meta=None,
 3968        public_key=None,
 3969        rate_limit=None,
 3970    ):
 3971        self.meta = meta if meta is not None else None
 3972        '''
 3973         Reserved for future use.
 3974        '''
 3975        self.public_key = public_key if public_key is not None else ''
 3976        '''
 3977         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3978         key format.
 3979        '''
 3980        self.rate_limit = rate_limit if rate_limit is not None else None
 3981        '''
 3982         Rate limit information.
 3983        '''
 3984
 3985    def __repr__(self):
 3986        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3987            'meta: ' + repr(self.meta) + ' ' +\
 3988            'public_key: ' + repr(self.public_key) + ' ' +\
 3989            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3990            '>'
 3991
 3992    def to_dict(self):
 3993        return {
 3994            'meta': self.meta,
 3995            'public_key': self.public_key,
 3996            'rate_limit': self.rate_limit,
 3997        }
 3998
 3999    @classmethod
 4000    def from_dict(cls, d):
 4001        return cls(
 4002            meta=d.get('meta'),
 4003            public_key=d.get('public_key'),
 4004            rate_limit=d.get('rate_limit'),
 4005        )
 4006
 4007
 4008class ControlPanelVerifyJWTResponse:
 4009    '''
 4010         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 4011    '''
 4012    __slots__ = [
 4013        'meta',
 4014        'rate_limit',
 4015        'valid',
 4016    ]
 4017
 4018    def __init__(
 4019        self,
 4020        meta=None,
 4021        rate_limit=None,
 4022        valid=None,
 4023    ):
 4024        self.meta = meta if meta is not None else None
 4025        '''
 4026         Reserved for future use.
 4027        '''
 4028        self.rate_limit = rate_limit if rate_limit is not None else None
 4029        '''
 4030         Rate limit information.
 4031        '''
 4032        self.valid = valid if valid is not None else False
 4033        '''
 4034         Reports if the given token is valid.
 4035        '''
 4036
 4037    def __repr__(self):
 4038        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 4039            'meta: ' + repr(self.meta) + ' ' +\
 4040            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 4041            'valid: ' + repr(self.valid) + ' ' +\
 4042            '>'
 4043
 4044    def to_dict(self):
 4045        return {
 4046            'meta': self.meta,
 4047            'rate_limit': self.rate_limit,
 4048            'valid': self.valid,
 4049        }
 4050
 4051    @classmethod
 4052    def from_dict(cls, d):
 4053        return cls(
 4054            meta=d.get('meta'),
 4055            rate_limit=d.get('rate_limit'),
 4056            valid=d.get('valid'),
 4057        )
 4058
 4059
 4060class CreateResponseMetadata:
 4061    '''
 4062         CreateResponseMetadata is reserved for future use.
 4063    '''
 4064    __slots__ = []
 4065
 4066    def __init__(self, ):
 4067        pass
 4068
 4069    def __repr__(self):
 4070        return '<sdm.CreateResponseMetadata ' + \
 4071            '>'
 4072
 4073    def to_dict(self):
 4074        return {}
 4075
 4076    @classmethod
 4077    def from_dict(cls, d):
 4078        return cls()
 4079
 4080
 4081class CyberarkConjurStore:
 4082    __slots__ = [
 4083        'appurl',
 4084        'id',
 4085        'name',
 4086        'tags',
 4087    ]
 4088
 4089    def __init__(
 4090        self,
 4091        appurl=None,
 4092        id=None,
 4093        name=None,
 4094        tags=None,
 4095    ):
 4096        self.appurl = appurl if appurl is not None else ''
 4097        self.id = id if id is not None else ''
 4098        '''
 4099         Unique identifier of the SecretStore.
 4100        '''
 4101        self.name = name if name is not None else ''
 4102        '''
 4103         Unique human-readable name of the SecretStore.
 4104        '''
 4105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4106        '''
 4107         Tags is a map of key, value pairs.
 4108        '''
 4109
 4110    def __repr__(self):
 4111        return '<sdm.CyberarkConjurStore ' + \
 4112            'appurl: ' + repr(self.appurl) + ' ' +\
 4113            'id: ' + repr(self.id) + ' ' +\
 4114            'name: ' + repr(self.name) + ' ' +\
 4115            'tags: ' + repr(self.tags) + ' ' +\
 4116            '>'
 4117
 4118    def to_dict(self):
 4119        return {
 4120            'appurl': self.appurl,
 4121            'id': self.id,
 4122            'name': self.name,
 4123            'tags': self.tags,
 4124        }
 4125
 4126    @classmethod
 4127    def from_dict(cls, d):
 4128        return cls(
 4129            appurl=d.get('appurl'),
 4130            id=d.get('id'),
 4131            name=d.get('name'),
 4132            tags=d.get('tags'),
 4133        )
 4134
 4135
 4136class CyberarkPAMExperimentalStore:
 4137    '''
 4138    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
 4139    without a major version bump.
 4140    '''
 4141    __slots__ = [
 4142        'appurl',
 4143        'id',
 4144        'name',
 4145        'tags',
 4146    ]
 4147
 4148    def __init__(
 4149        self,
 4150        appurl=None,
 4151        id=None,
 4152        name=None,
 4153        tags=None,
 4154    ):
 4155        self.appurl = appurl if appurl is not None else ''
 4156        self.id = id if id is not None else ''
 4157        '''
 4158         Unique identifier of the SecretStore.
 4159        '''
 4160        self.name = name if name is not None else ''
 4161        '''
 4162         Unique human-readable name of the SecretStore.
 4163        '''
 4164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4165        '''
 4166         Tags is a map of key, value pairs.
 4167        '''
 4168
 4169    def __repr__(self):
 4170        return '<sdm.CyberarkPAMExperimentalStore ' + \
 4171            'appurl: ' + repr(self.appurl) + ' ' +\
 4172            'id: ' + repr(self.id) + ' ' +\
 4173            'name: ' + repr(self.name) + ' ' +\
 4174            'tags: ' + repr(self.tags) + ' ' +\
 4175            '>'
 4176
 4177    def to_dict(self):
 4178        return {
 4179            'appurl': self.appurl,
 4180            'id': self.id,
 4181            'name': self.name,
 4182            'tags': self.tags,
 4183        }
 4184
 4185    @classmethod
 4186    def from_dict(cls, d):
 4187        return cls(
 4188            appurl=d.get('appurl'),
 4189            id=d.get('id'),
 4190            name=d.get('name'),
 4191            tags=d.get('tags'),
 4192        )
 4193
 4194
 4195class CyberarkPAMStore:
 4196    __slots__ = [
 4197        'appurl',
 4198        'id',
 4199        'name',
 4200        'tags',
 4201    ]
 4202
 4203    def __init__(
 4204        self,
 4205        appurl=None,
 4206        id=None,
 4207        name=None,
 4208        tags=None,
 4209    ):
 4210        self.appurl = appurl if appurl is not None else ''
 4211        self.id = id if id is not None else ''
 4212        '''
 4213         Unique identifier of the SecretStore.
 4214        '''
 4215        self.name = name if name is not None else ''
 4216        '''
 4217         Unique human-readable name of the SecretStore.
 4218        '''
 4219        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4220        '''
 4221         Tags is a map of key, value pairs.
 4222        '''
 4223
 4224    def __repr__(self):
 4225        return '<sdm.CyberarkPAMStore ' + \
 4226            'appurl: ' + repr(self.appurl) + ' ' +\
 4227            'id: ' + repr(self.id) + ' ' +\
 4228            'name: ' + repr(self.name) + ' ' +\
 4229            'tags: ' + repr(self.tags) + ' ' +\
 4230            '>'
 4231
 4232    def to_dict(self):
 4233        return {
 4234            'appurl': self.appurl,
 4235            'id': self.id,
 4236            'name': self.name,
 4237            'tags': self.tags,
 4238        }
 4239
 4240    @classmethod
 4241    def from_dict(cls, d):
 4242        return cls(
 4243            appurl=d.get('appurl'),
 4244            id=d.get('id'),
 4245            name=d.get('name'),
 4246            tags=d.get('tags'),
 4247        )
 4248
 4249
 4250class DB2I:
 4251    __slots__ = [
 4252        'bind_interface',
 4253        'egress_filter',
 4254        'healthy',
 4255        'hostname',
 4256        'id',
 4257        'name',
 4258        'password',
 4259        'port',
 4260        'port_override',
 4261        'secret_store_id',
 4262        'tags',
 4263        'tls_required',
 4264        'username',
 4265    ]
 4266
 4267    def __init__(
 4268        self,
 4269        bind_interface=None,
 4270        egress_filter=None,
 4271        healthy=None,
 4272        hostname=None,
 4273        id=None,
 4274        name=None,
 4275        password=None,
 4276        port=None,
 4277        port_override=None,
 4278        secret_store_id=None,
 4279        tags=None,
 4280        tls_required=None,
 4281        username=None,
 4282    ):
 4283        self.bind_interface = bind_interface if bind_interface is not None else ''
 4284        '''
 4285         Bind interface
 4286        '''
 4287        self.egress_filter = egress_filter if egress_filter is not None else ''
 4288        '''
 4289         A filter applied to the routing logic to pin datasource to nodes.
 4290        '''
 4291        self.healthy = healthy if healthy is not None else False
 4292        '''
 4293         True if the datasource is reachable and the credentials are valid.
 4294        '''
 4295        self.hostname = hostname if hostname is not None else ''
 4296        self.id = id if id is not None else ''
 4297        '''
 4298         Unique identifier of the Resource.
 4299        '''
 4300        self.name = name if name is not None else ''
 4301        '''
 4302         Unique human-readable name of the Resource.
 4303        '''
 4304        self.password = password if password is not None else ''
 4305        self.port = port if port is not None else 0
 4306        self.port_override = port_override if port_override is not None else 0
 4307        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4308        '''
 4309         ID of the secret store containing credentials for this resource, if any.
 4310        '''
 4311        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4312        '''
 4313         Tags is a map of key, value pairs.
 4314        '''
 4315        self.tls_required = tls_required if tls_required is not None else False
 4316        self.username = username if username is not None else ''
 4317
 4318    def __repr__(self):
 4319        return '<sdm.DB2I ' + \
 4320            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4321            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4322            'healthy: ' + repr(self.healthy) + ' ' +\
 4323            'hostname: ' + repr(self.hostname) + ' ' +\
 4324            'id: ' + repr(self.id) + ' ' +\
 4325            'name: ' + repr(self.name) + ' ' +\
 4326            'password: ' + repr(self.password) + ' ' +\
 4327            'port: ' + repr(self.port) + ' ' +\
 4328            'port_override: ' + repr(self.port_override) + ' ' +\
 4329            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4330            'tags: ' + repr(self.tags) + ' ' +\
 4331            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4332            'username: ' + repr(self.username) + ' ' +\
 4333            '>'
 4334
 4335    def to_dict(self):
 4336        return {
 4337            'bind_interface': self.bind_interface,
 4338            'egress_filter': self.egress_filter,
 4339            'healthy': self.healthy,
 4340            'hostname': self.hostname,
 4341            'id': self.id,
 4342            'name': self.name,
 4343            'password': self.password,
 4344            'port': self.port,
 4345            'port_override': self.port_override,
 4346            'secret_store_id': self.secret_store_id,
 4347            'tags': self.tags,
 4348            'tls_required': self.tls_required,
 4349            'username': self.username,
 4350        }
 4351
 4352    @classmethod
 4353    def from_dict(cls, d):
 4354        return cls(
 4355            bind_interface=d.get('bind_interface'),
 4356            egress_filter=d.get('egress_filter'),
 4357            healthy=d.get('healthy'),
 4358            hostname=d.get('hostname'),
 4359            id=d.get('id'),
 4360            name=d.get('name'),
 4361            password=d.get('password'),
 4362            port=d.get('port'),
 4363            port_override=d.get('port_override'),
 4364            secret_store_id=d.get('secret_store_id'),
 4365            tags=d.get('tags'),
 4366            tls_required=d.get('tls_required'),
 4367            username=d.get('username'),
 4368        )
 4369
 4370
 4371class DB2LUW:
 4372    __slots__ = [
 4373        'bind_interface',
 4374        'database',
 4375        'egress_filter',
 4376        'healthy',
 4377        'hostname',
 4378        'id',
 4379        'name',
 4380        'password',
 4381        'port',
 4382        'port_override',
 4383        'secret_store_id',
 4384        'tags',
 4385        'username',
 4386    ]
 4387
 4388    def __init__(
 4389        self,
 4390        bind_interface=None,
 4391        database=None,
 4392        egress_filter=None,
 4393        healthy=None,
 4394        hostname=None,
 4395        id=None,
 4396        name=None,
 4397        password=None,
 4398        port=None,
 4399        port_override=None,
 4400        secret_store_id=None,
 4401        tags=None,
 4402        username=None,
 4403    ):
 4404        self.bind_interface = bind_interface if bind_interface is not None else ''
 4405        '''
 4406         Bind interface
 4407        '''
 4408        self.database = database if database is not None else ''
 4409        self.egress_filter = egress_filter if egress_filter is not None else ''
 4410        '''
 4411         A filter applied to the routing logic to pin datasource to nodes.
 4412        '''
 4413        self.healthy = healthy if healthy is not None else False
 4414        '''
 4415         True if the datasource is reachable and the credentials are valid.
 4416        '''
 4417        self.hostname = hostname if hostname is not None else ''
 4418        self.id = id if id is not None else ''
 4419        '''
 4420         Unique identifier of the Resource.
 4421        '''
 4422        self.name = name if name is not None else ''
 4423        '''
 4424         Unique human-readable name of the Resource.
 4425        '''
 4426        self.password = password if password is not None else ''
 4427        self.port = port if port is not None else 0
 4428        self.port_override = port_override if port_override is not None else 0
 4429        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4430        '''
 4431         ID of the secret store containing credentials for this resource, if any.
 4432        '''
 4433        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4434        '''
 4435         Tags is a map of key, value pairs.
 4436        '''
 4437        self.username = username if username is not None else ''
 4438
 4439    def __repr__(self):
 4440        return '<sdm.DB2LUW ' + \
 4441            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4442            'database: ' + repr(self.database) + ' ' +\
 4443            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4444            'healthy: ' + repr(self.healthy) + ' ' +\
 4445            'hostname: ' + repr(self.hostname) + ' ' +\
 4446            'id: ' + repr(self.id) + ' ' +\
 4447            'name: ' + repr(self.name) + ' ' +\
 4448            'password: ' + repr(self.password) + ' ' +\
 4449            'port: ' + repr(self.port) + ' ' +\
 4450            'port_override: ' + repr(self.port_override) + ' ' +\
 4451            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4452            'tags: ' + repr(self.tags) + ' ' +\
 4453            'username: ' + repr(self.username) + ' ' +\
 4454            '>'
 4455
 4456    def to_dict(self):
 4457        return {
 4458            'bind_interface': self.bind_interface,
 4459            'database': self.database,
 4460            'egress_filter': self.egress_filter,
 4461            'healthy': self.healthy,
 4462            'hostname': self.hostname,
 4463            'id': self.id,
 4464            'name': self.name,
 4465            'password': self.password,
 4466            'port': self.port,
 4467            'port_override': self.port_override,
 4468            'secret_store_id': self.secret_store_id,
 4469            'tags': self.tags,
 4470            'username': self.username,
 4471        }
 4472
 4473    @classmethod
 4474    def from_dict(cls, d):
 4475        return cls(
 4476            bind_interface=d.get('bind_interface'),
 4477            database=d.get('database'),
 4478            egress_filter=d.get('egress_filter'),
 4479            healthy=d.get('healthy'),
 4480            hostname=d.get('hostname'),
 4481            id=d.get('id'),
 4482            name=d.get('name'),
 4483            password=d.get('password'),
 4484            port=d.get('port'),
 4485            port_override=d.get('port_override'),
 4486            secret_store_id=d.get('secret_store_id'),
 4487            tags=d.get('tags'),
 4488            username=d.get('username'),
 4489        )
 4490
 4491
 4492class DeleteResponseMetadata:
 4493    '''
 4494         DeleteResponseMetadata is reserved for future use.
 4495    '''
 4496    __slots__ = []
 4497
 4498    def __init__(self, ):
 4499        pass
 4500
 4501    def __repr__(self):
 4502        return '<sdm.DeleteResponseMetadata ' + \
 4503            '>'
 4504
 4505    def to_dict(self):
 4506        return {}
 4507
 4508    @classmethod
 4509    def from_dict(cls, d):
 4510        return cls()
 4511
 4512
 4513class DelineaStore:
 4514    '''
 4515    DelineaStore is currently unstable, and its API may change, or it may be removed,
 4516    without a major version bump.
 4517    '''
 4518    __slots__ = [
 4519        'id',
 4520        'name',
 4521        'server_url',
 4522        'tags',
 4523        'tenant_name',
 4524    ]
 4525
 4526    def __init__(
 4527        self,
 4528        id=None,
 4529        name=None,
 4530        server_url=None,
 4531        tags=None,
 4532        tenant_name=None,
 4533    ):
 4534        self.id = id if id is not None else ''
 4535        '''
 4536         Unique identifier of the SecretStore.
 4537        '''
 4538        self.name = name if name is not None else ''
 4539        '''
 4540         Unique human-readable name of the SecretStore.
 4541        '''
 4542        self.server_url = server_url if server_url is not None else ''
 4543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4544        '''
 4545         Tags is a map of key, value pairs.
 4546        '''
 4547        self.tenant_name = tenant_name if tenant_name is not None else ''
 4548
 4549    def __repr__(self):
 4550        return '<sdm.DelineaStore ' + \
 4551            'id: ' + repr(self.id) + ' ' +\
 4552            'name: ' + repr(self.name) + ' ' +\
 4553            'server_url: ' + repr(self.server_url) + ' ' +\
 4554            'tags: ' + repr(self.tags) + ' ' +\
 4555            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 4556            '>'
 4557
 4558    def to_dict(self):
 4559        return {
 4560            'id': self.id,
 4561            'name': self.name,
 4562            'server_url': self.server_url,
 4563            'tags': self.tags,
 4564            'tenant_name': self.tenant_name,
 4565        }
 4566
 4567    @classmethod
 4568    def from_dict(cls, d):
 4569        return cls(
 4570            id=d.get('id'),
 4571            name=d.get('name'),
 4572            server_url=d.get('server_url'),
 4573            tags=d.get('tags'),
 4574            tenant_name=d.get('tenant_name'),
 4575        )
 4576
 4577
 4578class DocumentDBHost:
 4579    __slots__ = [
 4580        'auth_database',
 4581        'bind_interface',
 4582        'egress_filter',
 4583        'healthy',
 4584        'hostname',
 4585        'id',
 4586        'name',
 4587        'password',
 4588        'port',
 4589        'port_override',
 4590        'secret_store_id',
 4591        'tags',
 4592        'username',
 4593    ]
 4594
 4595    def __init__(
 4596        self,
 4597        auth_database=None,
 4598        bind_interface=None,
 4599        egress_filter=None,
 4600        healthy=None,
 4601        hostname=None,
 4602        id=None,
 4603        name=None,
 4604        password=None,
 4605        port=None,
 4606        port_override=None,
 4607        secret_store_id=None,
 4608        tags=None,
 4609        username=None,
 4610    ):
 4611        self.auth_database = auth_database if auth_database is not None else ''
 4612        self.bind_interface = bind_interface if bind_interface is not None else ''
 4613        '''
 4614         Bind interface
 4615        '''
 4616        self.egress_filter = egress_filter if egress_filter is not None else ''
 4617        '''
 4618         A filter applied to the routing logic to pin datasource to nodes.
 4619        '''
 4620        self.healthy = healthy if healthy is not None else False
 4621        '''
 4622         True if the datasource is reachable and the credentials are valid.
 4623        '''
 4624        self.hostname = hostname if hostname is not None else ''
 4625        self.id = id if id is not None else ''
 4626        '''
 4627         Unique identifier of the Resource.
 4628        '''
 4629        self.name = name if name is not None else ''
 4630        '''
 4631         Unique human-readable name of the Resource.
 4632        '''
 4633        self.password = password if password is not None else ''
 4634        self.port = port if port is not None else 0
 4635        self.port_override = port_override if port_override is not None else 0
 4636        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4637        '''
 4638         ID of the secret store containing credentials for this resource, if any.
 4639        '''
 4640        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4641        '''
 4642         Tags is a map of key, value pairs.
 4643        '''
 4644        self.username = username if username is not None else ''
 4645
 4646    def __repr__(self):
 4647        return '<sdm.DocumentDBHost ' + \
 4648            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4649            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4650            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4651            'healthy: ' + repr(self.healthy) + ' ' +\
 4652            'hostname: ' + repr(self.hostname) + ' ' +\
 4653            'id: ' + repr(self.id) + ' ' +\
 4654            'name: ' + repr(self.name) + ' ' +\
 4655            'password: ' + repr(self.password) + ' ' +\
 4656            'port: ' + repr(self.port) + ' ' +\
 4657            'port_override: ' + repr(self.port_override) + ' ' +\
 4658            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4659            'tags: ' + repr(self.tags) + ' ' +\
 4660            'username: ' + repr(self.username) + ' ' +\
 4661            '>'
 4662
 4663    def to_dict(self):
 4664        return {
 4665            'auth_database': self.auth_database,
 4666            'bind_interface': self.bind_interface,
 4667            'egress_filter': self.egress_filter,
 4668            'healthy': self.healthy,
 4669            'hostname': self.hostname,
 4670            'id': self.id,
 4671            'name': self.name,
 4672            'password': self.password,
 4673            'port': self.port,
 4674            'port_override': self.port_override,
 4675            'secret_store_id': self.secret_store_id,
 4676            'tags': self.tags,
 4677            'username': self.username,
 4678        }
 4679
 4680    @classmethod
 4681    def from_dict(cls, d):
 4682        return cls(
 4683            auth_database=d.get('auth_database'),
 4684            bind_interface=d.get('bind_interface'),
 4685            egress_filter=d.get('egress_filter'),
 4686            healthy=d.get('healthy'),
 4687            hostname=d.get('hostname'),
 4688            id=d.get('id'),
 4689            name=d.get('name'),
 4690            password=d.get('password'),
 4691            port=d.get('port'),
 4692            port_override=d.get('port_override'),
 4693            secret_store_id=d.get('secret_store_id'),
 4694            tags=d.get('tags'),
 4695            username=d.get('username'),
 4696        )
 4697
 4698
 4699class DocumentDBReplicaSet:
 4700    __slots__ = [
 4701        'auth_database',
 4702        'bind_interface',
 4703        'connect_to_replica',
 4704        'egress_filter',
 4705        'healthy',
 4706        'hostname',
 4707        'id',
 4708        'name',
 4709        'password',
 4710        'port_override',
 4711        'replica_set',
 4712        'secret_store_id',
 4713        'tags',
 4714        'username',
 4715    ]
 4716
 4717    def __init__(
 4718        self,
 4719        auth_database=None,
 4720        bind_interface=None,
 4721        connect_to_replica=None,
 4722        egress_filter=None,
 4723        healthy=None,
 4724        hostname=None,
 4725        id=None,
 4726        name=None,
 4727        password=None,
 4728        port_override=None,
 4729        replica_set=None,
 4730        secret_store_id=None,
 4731        tags=None,
 4732        username=None,
 4733    ):
 4734        self.auth_database = auth_database if auth_database is not None else ''
 4735        self.bind_interface = bind_interface if bind_interface is not None else ''
 4736        '''
 4737         Bind interface
 4738        '''
 4739        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4740        self.egress_filter = egress_filter if egress_filter is not None else ''
 4741        '''
 4742         A filter applied to the routing logic to pin datasource to nodes.
 4743        '''
 4744        self.healthy = healthy if healthy is not None else False
 4745        '''
 4746         True if the datasource is reachable and the credentials are valid.
 4747        '''
 4748        self.hostname = hostname if hostname is not None else ''
 4749        '''
 4750         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4751        '''
 4752        self.id = id if id is not None else ''
 4753        '''
 4754         Unique identifier of the Resource.
 4755        '''
 4756        self.name = name if name is not None else ''
 4757        '''
 4758         Unique human-readable name of the Resource.
 4759        '''
 4760        self.password = password if password is not None else ''
 4761        self.port_override = port_override if port_override is not None else 0
 4762        self.replica_set = replica_set if replica_set is not None else ''
 4763        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4764        '''
 4765         ID of the secret store containing credentials for this resource, if any.
 4766        '''
 4767        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4768        '''
 4769         Tags is a map of key, value pairs.
 4770        '''
 4771        self.username = username if username is not None else ''
 4772
 4773    def __repr__(self):
 4774        return '<sdm.DocumentDBReplicaSet ' + \
 4775            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4776            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4777            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4779            'healthy: ' + repr(self.healthy) + ' ' +\
 4780            'hostname: ' + repr(self.hostname) + ' ' +\
 4781            'id: ' + repr(self.id) + ' ' +\
 4782            'name: ' + repr(self.name) + ' ' +\
 4783            'password: ' + repr(self.password) + ' ' +\
 4784            'port_override: ' + repr(self.port_override) + ' ' +\
 4785            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4786            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4787            'tags: ' + repr(self.tags) + ' ' +\
 4788            'username: ' + repr(self.username) + ' ' +\
 4789            '>'
 4790
 4791    def to_dict(self):
 4792        return {
 4793            'auth_database': self.auth_database,
 4794            'bind_interface': self.bind_interface,
 4795            'connect_to_replica': self.connect_to_replica,
 4796            'egress_filter': self.egress_filter,
 4797            'healthy': self.healthy,
 4798            'hostname': self.hostname,
 4799            'id': self.id,
 4800            'name': self.name,
 4801            'password': self.password,
 4802            'port_override': self.port_override,
 4803            'replica_set': self.replica_set,
 4804            'secret_store_id': self.secret_store_id,
 4805            'tags': self.tags,
 4806            'username': self.username,
 4807        }
 4808
 4809    @classmethod
 4810    def from_dict(cls, d):
 4811        return cls(
 4812            auth_database=d.get('auth_database'),
 4813            bind_interface=d.get('bind_interface'),
 4814            connect_to_replica=d.get('connect_to_replica'),
 4815            egress_filter=d.get('egress_filter'),
 4816            healthy=d.get('healthy'),
 4817            hostname=d.get('hostname'),
 4818            id=d.get('id'),
 4819            name=d.get('name'),
 4820            password=d.get('password'),
 4821            port_override=d.get('port_override'),
 4822            replica_set=d.get('replica_set'),
 4823            secret_store_id=d.get('secret_store_id'),
 4824            tags=d.get('tags'),
 4825            username=d.get('username'),
 4826        )
 4827
 4828
 4829class Druid:
 4830    __slots__ = [
 4831        'bind_interface',
 4832        'egress_filter',
 4833        'healthy',
 4834        'hostname',
 4835        'id',
 4836        'name',
 4837        'password',
 4838        'port',
 4839        'port_override',
 4840        'secret_store_id',
 4841        'tags',
 4842        'username',
 4843    ]
 4844
 4845    def __init__(
 4846        self,
 4847        bind_interface=None,
 4848        egress_filter=None,
 4849        healthy=None,
 4850        hostname=None,
 4851        id=None,
 4852        name=None,
 4853        password=None,
 4854        port=None,
 4855        port_override=None,
 4856        secret_store_id=None,
 4857        tags=None,
 4858        username=None,
 4859    ):
 4860        self.bind_interface = bind_interface if bind_interface is not None else ''
 4861        '''
 4862         Bind interface
 4863        '''
 4864        self.egress_filter = egress_filter if egress_filter is not None else ''
 4865        '''
 4866         A filter applied to the routing logic to pin datasource to nodes.
 4867        '''
 4868        self.healthy = healthy if healthy is not None else False
 4869        '''
 4870         True if the datasource is reachable and the credentials are valid.
 4871        '''
 4872        self.hostname = hostname if hostname is not None else ''
 4873        self.id = id if id is not None else ''
 4874        '''
 4875         Unique identifier of the Resource.
 4876        '''
 4877        self.name = name if name is not None else ''
 4878        '''
 4879         Unique human-readable name of the Resource.
 4880        '''
 4881        self.password = password if password is not None else ''
 4882        self.port = port if port is not None else 0
 4883        self.port_override = port_override if port_override is not None else 0
 4884        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4885        '''
 4886         ID of the secret store containing credentials for this resource, if any.
 4887        '''
 4888        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4889        '''
 4890         Tags is a map of key, value pairs.
 4891        '''
 4892        self.username = username if username is not None else ''
 4893
 4894    def __repr__(self):
 4895        return '<sdm.Druid ' + \
 4896            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4897            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4898            'healthy: ' + repr(self.healthy) + ' ' +\
 4899            'hostname: ' + repr(self.hostname) + ' ' +\
 4900            'id: ' + repr(self.id) + ' ' +\
 4901            'name: ' + repr(self.name) + ' ' +\
 4902            'password: ' + repr(self.password) + ' ' +\
 4903            'port: ' + repr(self.port) + ' ' +\
 4904            'port_override: ' + repr(self.port_override) + ' ' +\
 4905            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4906            'tags: ' + repr(self.tags) + ' ' +\
 4907            'username: ' + repr(self.username) + ' ' +\
 4908            '>'
 4909
 4910    def to_dict(self):
 4911        return {
 4912            'bind_interface': self.bind_interface,
 4913            'egress_filter': self.egress_filter,
 4914            'healthy': self.healthy,
 4915            'hostname': self.hostname,
 4916            'id': self.id,
 4917            'name': self.name,
 4918            'password': self.password,
 4919            'port': self.port,
 4920            'port_override': self.port_override,
 4921            'secret_store_id': self.secret_store_id,
 4922            'tags': self.tags,
 4923            'username': self.username,
 4924        }
 4925
 4926    @classmethod
 4927    def from_dict(cls, d):
 4928        return cls(
 4929            bind_interface=d.get('bind_interface'),
 4930            egress_filter=d.get('egress_filter'),
 4931            healthy=d.get('healthy'),
 4932            hostname=d.get('hostname'),
 4933            id=d.get('id'),
 4934            name=d.get('name'),
 4935            password=d.get('password'),
 4936            port=d.get('port'),
 4937            port_override=d.get('port_override'),
 4938            secret_store_id=d.get('secret_store_id'),
 4939            tags=d.get('tags'),
 4940            username=d.get('username'),
 4941        )
 4942
 4943
 4944class DynamoDB:
 4945    __slots__ = [
 4946        'access_key',
 4947        'bind_interface',
 4948        'egress_filter',
 4949        'endpoint',
 4950        'healthy',
 4951        'id',
 4952        'name',
 4953        'port_override',
 4954        'region',
 4955        'role_arn',
 4956        'role_external_id',
 4957        'secret_access_key',
 4958        'secret_store_id',
 4959        'tags',
 4960    ]
 4961
 4962    def __init__(
 4963        self,
 4964        access_key=None,
 4965        bind_interface=None,
 4966        egress_filter=None,
 4967        endpoint=None,
 4968        healthy=None,
 4969        id=None,
 4970        name=None,
 4971        port_override=None,
 4972        region=None,
 4973        role_arn=None,
 4974        role_external_id=None,
 4975        secret_access_key=None,
 4976        secret_store_id=None,
 4977        tags=None,
 4978    ):
 4979        self.access_key = access_key if access_key is not None else ''
 4980        self.bind_interface = bind_interface if bind_interface is not None else ''
 4981        '''
 4982         Bind interface
 4983        '''
 4984        self.egress_filter = egress_filter if egress_filter is not None else ''
 4985        '''
 4986         A filter applied to the routing logic to pin datasource to nodes.
 4987        '''
 4988        self.endpoint = endpoint if endpoint is not None else ''
 4989        self.healthy = healthy if healthy is not None else False
 4990        '''
 4991         True if the datasource is reachable and the credentials are valid.
 4992        '''
 4993        self.id = id if id is not None else ''
 4994        '''
 4995         Unique identifier of the Resource.
 4996        '''
 4997        self.name = name if name is not None else ''
 4998        '''
 4999         Unique human-readable name of the Resource.
 5000        '''
 5001        self.port_override = port_override if port_override is not None else 0
 5002        self.region = region if region is not None else ''
 5003        self.role_arn = role_arn if role_arn is not None else ''
 5004        self.role_external_id = role_external_id if role_external_id is not None else ''
 5005        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 5006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5007        '''
 5008         ID of the secret store containing credentials for this resource, if any.
 5009        '''
 5010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5011        '''
 5012         Tags is a map of key, value pairs.
 5013        '''
 5014
 5015    def __repr__(self):
 5016        return '<sdm.DynamoDB ' + \
 5017            'access_key: ' + repr(self.access_key) + ' ' +\
 5018            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5019            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5020            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5021            'healthy: ' + repr(self.healthy) + ' ' +\
 5022            'id: ' + repr(self.id) + ' ' +\
 5023            'name: ' + repr(self.name) + ' ' +\
 5024            'port_override: ' + repr(self.port_override) + ' ' +\
 5025            'region: ' + repr(self.region) + ' ' +\
 5026            'role_arn: ' + repr(self.role_arn) + ' ' +\
 5027            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 5028            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 5029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5030            'tags: ' + repr(self.tags) + ' ' +\
 5031            '>'
 5032
 5033    def to_dict(self):
 5034        return {
 5035            'access_key': self.access_key,
 5036            'bind_interface': self.bind_interface,
 5037            'egress_filter': self.egress_filter,
 5038            'endpoint': self.endpoint,
 5039            'healthy': self.healthy,
 5040            'id': self.id,
 5041            'name': self.name,
 5042            'port_override': self.port_override,
 5043            'region': self.region,
 5044            'role_arn': self.role_arn,
 5045            'role_external_id': self.role_external_id,
 5046            'secret_access_key': self.secret_access_key,
 5047            'secret_store_id': self.secret_store_id,
 5048            'tags': self.tags,
 5049        }
 5050
 5051    @classmethod
 5052    def from_dict(cls, d):
 5053        return cls(
 5054            access_key=d.get('access_key'),
 5055            bind_interface=d.get('bind_interface'),
 5056            egress_filter=d.get('egress_filter'),
 5057            endpoint=d.get('endpoint'),
 5058            healthy=d.get('healthy'),
 5059            id=d.get('id'),
 5060            name=d.get('name'),
 5061            port_override=d.get('port_override'),
 5062            region=d.get('region'),
 5063            role_arn=d.get('role_arn'),
 5064            role_external_id=d.get('role_external_id'),
 5065            secret_access_key=d.get('secret_access_key'),
 5066            secret_store_id=d.get('secret_store_id'),
 5067            tags=d.get('tags'),
 5068        )
 5069
 5070
 5071class Elastic:
 5072    __slots__ = [
 5073        'bind_interface',
 5074        'egress_filter',
 5075        'healthy',
 5076        'hostname',
 5077        'id',
 5078        'name',
 5079        'password',
 5080        'port',
 5081        'port_override',
 5082        'secret_store_id',
 5083        'tags',
 5084        'tls_required',
 5085        'username',
 5086    ]
 5087
 5088    def __init__(
 5089        self,
 5090        bind_interface=None,
 5091        egress_filter=None,
 5092        healthy=None,
 5093        hostname=None,
 5094        id=None,
 5095        name=None,
 5096        password=None,
 5097        port=None,
 5098        port_override=None,
 5099        secret_store_id=None,
 5100        tags=None,
 5101        tls_required=None,
 5102        username=None,
 5103    ):
 5104        self.bind_interface = bind_interface if bind_interface is not None else ''
 5105        '''
 5106         Bind interface
 5107        '''
 5108        self.egress_filter = egress_filter if egress_filter is not None else ''
 5109        '''
 5110         A filter applied to the routing logic to pin datasource to nodes.
 5111        '''
 5112        self.healthy = healthy if healthy is not None else False
 5113        '''
 5114         True if the datasource is reachable and the credentials are valid.
 5115        '''
 5116        self.hostname = hostname if hostname is not None else ''
 5117        self.id = id if id is not None else ''
 5118        '''
 5119         Unique identifier of the Resource.
 5120        '''
 5121        self.name = name if name is not None else ''
 5122        '''
 5123         Unique human-readable name of the Resource.
 5124        '''
 5125        self.password = password if password is not None else ''
 5126        self.port = port if port is not None else 0
 5127        self.port_override = port_override if port_override is not None else 0
 5128        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5129        '''
 5130         ID of the secret store containing credentials for this resource, if any.
 5131        '''
 5132        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5133        '''
 5134         Tags is a map of key, value pairs.
 5135        '''
 5136        self.tls_required = tls_required if tls_required is not None else False
 5137        self.username = username if username is not None else ''
 5138
 5139    def __repr__(self):
 5140        return '<sdm.Elastic ' + \
 5141            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5142            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5143            'healthy: ' + repr(self.healthy) + ' ' +\
 5144            'hostname: ' + repr(self.hostname) + ' ' +\
 5145            'id: ' + repr(self.id) + ' ' +\
 5146            'name: ' + repr(self.name) + ' ' +\
 5147            'password: ' + repr(self.password) + ' ' +\
 5148            'port: ' + repr(self.port) + ' ' +\
 5149            'port_override: ' + repr(self.port_override) + ' ' +\
 5150            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5151            'tags: ' + repr(self.tags) + ' ' +\
 5152            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5153            'username: ' + repr(self.username) + ' ' +\
 5154            '>'
 5155
 5156    def to_dict(self):
 5157        return {
 5158            'bind_interface': self.bind_interface,
 5159            'egress_filter': self.egress_filter,
 5160            'healthy': self.healthy,
 5161            'hostname': self.hostname,
 5162            'id': self.id,
 5163            'name': self.name,
 5164            'password': self.password,
 5165            'port': self.port,
 5166            'port_override': self.port_override,
 5167            'secret_store_id': self.secret_store_id,
 5168            'tags': self.tags,
 5169            'tls_required': self.tls_required,
 5170            'username': self.username,
 5171        }
 5172
 5173    @classmethod
 5174    def from_dict(cls, d):
 5175        return cls(
 5176            bind_interface=d.get('bind_interface'),
 5177            egress_filter=d.get('egress_filter'),
 5178            healthy=d.get('healthy'),
 5179            hostname=d.get('hostname'),
 5180            id=d.get('id'),
 5181            name=d.get('name'),
 5182            password=d.get('password'),
 5183            port=d.get('port'),
 5184            port_override=d.get('port_override'),
 5185            secret_store_id=d.get('secret_store_id'),
 5186            tags=d.get('tags'),
 5187            tls_required=d.get('tls_required'),
 5188            username=d.get('username'),
 5189        )
 5190
 5191
 5192class ElasticacheRedis:
 5193    __slots__ = [
 5194        'bind_interface',
 5195        'egress_filter',
 5196        'healthy',
 5197        'hostname',
 5198        'id',
 5199        'name',
 5200        'password',
 5201        'port',
 5202        'port_override',
 5203        'secret_store_id',
 5204        'tags',
 5205        'tls_required',
 5206        'username',
 5207    ]
 5208
 5209    def __init__(
 5210        self,
 5211        bind_interface=None,
 5212        egress_filter=None,
 5213        healthy=None,
 5214        hostname=None,
 5215        id=None,
 5216        name=None,
 5217        password=None,
 5218        port=None,
 5219        port_override=None,
 5220        secret_store_id=None,
 5221        tags=None,
 5222        tls_required=None,
 5223        username=None,
 5224    ):
 5225        self.bind_interface = bind_interface if bind_interface is not None else ''
 5226        '''
 5227         Bind interface
 5228        '''
 5229        self.egress_filter = egress_filter if egress_filter is not None else ''
 5230        '''
 5231         A filter applied to the routing logic to pin datasource to nodes.
 5232        '''
 5233        self.healthy = healthy if healthy is not None else False
 5234        '''
 5235         True if the datasource is reachable and the credentials are valid.
 5236        '''
 5237        self.hostname = hostname if hostname is not None else ''
 5238        self.id = id if id is not None else ''
 5239        '''
 5240         Unique identifier of the Resource.
 5241        '''
 5242        self.name = name if name is not None else ''
 5243        '''
 5244         Unique human-readable name of the Resource.
 5245        '''
 5246        self.password = password if password is not None else ''
 5247        self.port = port if port is not None else 0
 5248        self.port_override = port_override if port_override is not None else 0
 5249        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5250        '''
 5251         ID of the secret store containing credentials for this resource, if any.
 5252        '''
 5253        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5254        '''
 5255         Tags is a map of key, value pairs.
 5256        '''
 5257        self.tls_required = tls_required if tls_required is not None else False
 5258        self.username = username if username is not None else ''
 5259
 5260    def __repr__(self):
 5261        return '<sdm.ElasticacheRedis ' + \
 5262            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5263            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5264            'healthy: ' + repr(self.healthy) + ' ' +\
 5265            'hostname: ' + repr(self.hostname) + ' ' +\
 5266            'id: ' + repr(self.id) + ' ' +\
 5267            'name: ' + repr(self.name) + ' ' +\
 5268            'password: ' + repr(self.password) + ' ' +\
 5269            'port: ' + repr(self.port) + ' ' +\
 5270            'port_override: ' + repr(self.port_override) + ' ' +\
 5271            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5272            'tags: ' + repr(self.tags) + ' ' +\
 5273            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5274            'username: ' + repr(self.username) + ' ' +\
 5275            '>'
 5276
 5277    def to_dict(self):
 5278        return {
 5279            'bind_interface': self.bind_interface,
 5280            'egress_filter': self.egress_filter,
 5281            'healthy': self.healthy,
 5282            'hostname': self.hostname,
 5283            'id': self.id,
 5284            'name': self.name,
 5285            'password': self.password,
 5286            'port': self.port,
 5287            'port_override': self.port_override,
 5288            'secret_store_id': self.secret_store_id,
 5289            'tags': self.tags,
 5290            'tls_required': self.tls_required,
 5291            'username': self.username,
 5292        }
 5293
 5294    @classmethod
 5295    def from_dict(cls, d):
 5296        return cls(
 5297            bind_interface=d.get('bind_interface'),
 5298            egress_filter=d.get('egress_filter'),
 5299            healthy=d.get('healthy'),
 5300            hostname=d.get('hostname'),
 5301            id=d.get('id'),
 5302            name=d.get('name'),
 5303            password=d.get('password'),
 5304            port=d.get('port'),
 5305            port_override=d.get('port_override'),
 5306            secret_store_id=d.get('secret_store_id'),
 5307            tags=d.get('tags'),
 5308            tls_required=d.get('tls_required'),
 5309            username=d.get('username'),
 5310        )
 5311
 5312
 5313class GCP:
 5314    __slots__ = [
 5315        'bind_interface',
 5316        'egress_filter',
 5317        'healthy',
 5318        'id',
 5319        'keyfile',
 5320        'name',
 5321        'scopes',
 5322        'secret_store_id',
 5323        'tags',
 5324    ]
 5325
 5326    def __init__(
 5327        self,
 5328        bind_interface=None,
 5329        egress_filter=None,
 5330        healthy=None,
 5331        id=None,
 5332        keyfile=None,
 5333        name=None,
 5334        scopes=None,
 5335        secret_store_id=None,
 5336        tags=None,
 5337    ):
 5338        self.bind_interface = bind_interface if bind_interface is not None else ''
 5339        '''
 5340         Bind interface
 5341        '''
 5342        self.egress_filter = egress_filter if egress_filter is not None else ''
 5343        '''
 5344         A filter applied to the routing logic to pin datasource to nodes.
 5345        '''
 5346        self.healthy = healthy if healthy is not None else False
 5347        '''
 5348         True if the datasource is reachable and the credentials are valid.
 5349        '''
 5350        self.id = id if id is not None else ''
 5351        '''
 5352         Unique identifier of the Resource.
 5353        '''
 5354        self.keyfile = keyfile if keyfile is not None else ''
 5355        self.name = name if name is not None else ''
 5356        '''
 5357         Unique human-readable name of the Resource.
 5358        '''
 5359        self.scopes = scopes if scopes is not None else ''
 5360        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5361        '''
 5362         ID of the secret store containing credentials for this resource, if any.
 5363        '''
 5364        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5365        '''
 5366         Tags is a map of key, value pairs.
 5367        '''
 5368
 5369    def __repr__(self):
 5370        return '<sdm.GCP ' + \
 5371            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5372            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5373            'healthy: ' + repr(self.healthy) + ' ' +\
 5374            'id: ' + repr(self.id) + ' ' +\
 5375            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5376            'name: ' + repr(self.name) + ' ' +\
 5377            'scopes: ' + repr(self.scopes) + ' ' +\
 5378            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5379            'tags: ' + repr(self.tags) + ' ' +\
 5380            '>'
 5381
 5382    def to_dict(self):
 5383        return {
 5384            'bind_interface': self.bind_interface,
 5385            'egress_filter': self.egress_filter,
 5386            'healthy': self.healthy,
 5387            'id': self.id,
 5388            'keyfile': self.keyfile,
 5389            'name': self.name,
 5390            'scopes': self.scopes,
 5391            'secret_store_id': self.secret_store_id,
 5392            'tags': self.tags,
 5393        }
 5394
 5395    @classmethod
 5396    def from_dict(cls, d):
 5397        return cls(
 5398            bind_interface=d.get('bind_interface'),
 5399            egress_filter=d.get('egress_filter'),
 5400            healthy=d.get('healthy'),
 5401            id=d.get('id'),
 5402            keyfile=d.get('keyfile'),
 5403            name=d.get('name'),
 5404            scopes=d.get('scopes'),
 5405            secret_store_id=d.get('secret_store_id'),
 5406            tags=d.get('tags'),
 5407        )
 5408
 5409
 5410class GCPStore:
 5411    __slots__ = [
 5412        'id',
 5413        'name',
 5414        'projectid',
 5415        'tags',
 5416    ]
 5417
 5418    def __init__(
 5419        self,
 5420        id=None,
 5421        name=None,
 5422        projectid=None,
 5423        tags=None,
 5424    ):
 5425        self.id = id if id is not None else ''
 5426        '''
 5427         Unique identifier of the SecretStore.
 5428        '''
 5429        self.name = name if name is not None else ''
 5430        '''
 5431         Unique human-readable name of the SecretStore.
 5432        '''
 5433        self.projectid = projectid if projectid is not None else ''
 5434        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5435        '''
 5436         Tags is a map of key, value pairs.
 5437        '''
 5438
 5439    def __repr__(self):
 5440        return '<sdm.GCPStore ' + \
 5441            'id: ' + repr(self.id) + ' ' +\
 5442            'name: ' + repr(self.name) + ' ' +\
 5443            'projectid: ' + repr(self.projectid) + ' ' +\
 5444            'tags: ' + repr(self.tags) + ' ' +\
 5445            '>'
 5446
 5447    def to_dict(self):
 5448        return {
 5449            'id': self.id,
 5450            'name': self.name,
 5451            'projectid': self.projectid,
 5452            'tags': self.tags,
 5453        }
 5454
 5455    @classmethod
 5456    def from_dict(cls, d):
 5457        return cls(
 5458            id=d.get('id'),
 5459            name=d.get('name'),
 5460            projectid=d.get('projectid'),
 5461            tags=d.get('tags'),
 5462        )
 5463
 5464
 5465class Gateway:
 5466    '''
 5467         Gateway represents a StrongDM CLI installation running in gateway mode.
 5468    '''
 5469    __slots__ = [
 5470        'bind_address',
 5471        'device',
 5472        'gateway_filter',
 5473        'id',
 5474        'listen_address',
 5475        'location',
 5476        'name',
 5477        'state',
 5478        'tags',
 5479        'version',
 5480    ]
 5481
 5482    def __init__(
 5483        self,
 5484        bind_address=None,
 5485        device=None,
 5486        gateway_filter=None,
 5487        id=None,
 5488        listen_address=None,
 5489        location=None,
 5490        name=None,
 5491        state=None,
 5492        tags=None,
 5493        version=None,
 5494    ):
 5495        self.bind_address = bind_address if bind_address is not None else ''
 5496        '''
 5497         The hostname/port tuple which the gateway daemon will bind to.
 5498         If not provided on create, set to "0.0.0.0:listen_address_port".
 5499        '''
 5500        self.device = device if device is not None else ''
 5501        '''
 5502         Device is a read only device name uploaded by the gateway process when 
 5503         it comes online.
 5504        '''
 5505        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5506        '''
 5507         GatewayFilter can be used to restrict the peering between relays and
 5508         gateways.
 5509        '''
 5510        self.id = id if id is not None else ''
 5511        '''
 5512         Unique identifier of the Gateway.
 5513        '''
 5514        self.listen_address = listen_address if listen_address is not None else ''
 5515        '''
 5516         The public hostname/port tuple at which the gateway will be accessible to clients.
 5517        '''
 5518        self.location = location if location is not None else ''
 5519        '''
 5520         Location is a read only network location uploaded by the gateway process
 5521         when it comes online.
 5522        '''
 5523        self.name = name if name is not None else ''
 5524        '''
 5525         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5526        '''
 5527        self.state = state if state is not None else ''
 5528        '''
 5529         The current state of the gateway. One of: "new", "verifying_restart",
 5530         "restarting", "started", "stopped", "dead", "unknown"
 5531        '''
 5532        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5533        '''
 5534         Tags is a map of key, value pairs.
 5535        '''
 5536        self.version = version if version is not None else ''
 5537        '''
 5538         Version is a read only sdm binary version uploaded by the gateway process
 5539         when it comes online.
 5540        '''
 5541
 5542    def __repr__(self):
 5543        return '<sdm.Gateway ' + \
 5544            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5545            'device: ' + repr(self.device) + ' ' +\
 5546            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5547            'id: ' + repr(self.id) + ' ' +\
 5548            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5549            'location: ' + repr(self.location) + ' ' +\
 5550            'name: ' + repr(self.name) + ' ' +\
 5551            'state: ' + repr(self.state) + ' ' +\
 5552            'tags: ' + repr(self.tags) + ' ' +\
 5553            'version: ' + repr(self.version) + ' ' +\
 5554            '>'
 5555
 5556    def to_dict(self):
 5557        return {
 5558            'bind_address': self.bind_address,
 5559            'device': self.device,
 5560            'gateway_filter': self.gateway_filter,
 5561            'id': self.id,
 5562            'listen_address': self.listen_address,
 5563            'location': self.location,
 5564            'name': self.name,
 5565            'state': self.state,
 5566            'tags': self.tags,
 5567            'version': self.version,
 5568        }
 5569
 5570    @classmethod
 5571    def from_dict(cls, d):
 5572        return cls(
 5573            bind_address=d.get('bind_address'),
 5574            device=d.get('device'),
 5575            gateway_filter=d.get('gateway_filter'),
 5576            id=d.get('id'),
 5577            listen_address=d.get('listen_address'),
 5578            location=d.get('location'),
 5579            name=d.get('name'),
 5580            state=d.get('state'),
 5581            tags=d.get('tags'),
 5582            version=d.get('version'),
 5583        )
 5584
 5585
 5586class GetResponseMetadata:
 5587    '''
 5588         GetResponseMetadata is reserved for future use.
 5589    '''
 5590    __slots__ = []
 5591
 5592    def __init__(self, ):
 5593        pass
 5594
 5595    def __repr__(self):
 5596        return '<sdm.GetResponseMetadata ' + \
 5597            '>'
 5598
 5599    def to_dict(self):
 5600        return {}
 5601
 5602    @classmethod
 5603    def from_dict(cls, d):
 5604        return cls()
 5605
 5606
 5607class GoogleGKE:
 5608    __slots__ = [
 5609        'bind_interface',
 5610        'certificate_authority',
 5611        'egress_filter',
 5612        'endpoint',
 5613        'healthcheck_namespace',
 5614        'healthy',
 5615        'id',
 5616        'name',
 5617        'remote_identity_group_id',
 5618        'remote_identity_healthcheck_username',
 5619        'secret_store_id',
 5620        'service_account_key',
 5621        'tags',
 5622    ]
 5623
 5624    def __init__(
 5625        self,
 5626        bind_interface=None,
 5627        certificate_authority=None,
 5628        egress_filter=None,
 5629        endpoint=None,
 5630        healthcheck_namespace=None,
 5631        healthy=None,
 5632        id=None,
 5633        name=None,
 5634        remote_identity_group_id=None,
 5635        remote_identity_healthcheck_username=None,
 5636        secret_store_id=None,
 5637        service_account_key=None,
 5638        tags=None,
 5639    ):
 5640        self.bind_interface = bind_interface if bind_interface is not None else ''
 5641        '''
 5642         Bind interface
 5643        '''
 5644        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5645        self.egress_filter = egress_filter if egress_filter is not None else ''
 5646        '''
 5647         A filter applied to the routing logic to pin datasource to nodes.
 5648        '''
 5649        self.endpoint = endpoint if endpoint is not None else ''
 5650        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5651        '''
 5652         The path used to check the health of your connection.  Defaults to `default`.
 5653        '''
 5654        self.healthy = healthy if healthy is not None else False
 5655        '''
 5656         True if the datasource is reachable and the credentials are valid.
 5657        '''
 5658        self.id = id if id is not None else ''
 5659        '''
 5660         Unique identifier of the Resource.
 5661        '''
 5662        self.name = name if name is not None else ''
 5663        '''
 5664         Unique human-readable name of the Resource.
 5665        '''
 5666        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5667        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5668        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5669        '''
 5670         ID of the secret store containing credentials for this resource, if any.
 5671        '''
 5672        self.service_account_key = service_account_key if service_account_key is not None else ''
 5673        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5674        '''
 5675         Tags is a map of key, value pairs.
 5676        '''
 5677
 5678    def __repr__(self):
 5679        return '<sdm.GoogleGKE ' + \
 5680            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5681            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5682            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5683            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5684            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5685            'healthy: ' + repr(self.healthy) + ' ' +\
 5686            'id: ' + repr(self.id) + ' ' +\
 5687            'name: ' + repr(self.name) + ' ' +\
 5688            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5689            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5690            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5691            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5692            'tags: ' + repr(self.tags) + ' ' +\
 5693            '>'
 5694
 5695    def to_dict(self):
 5696        return {
 5697            'bind_interface': self.bind_interface,
 5698            'certificate_authority': self.certificate_authority,
 5699            'egress_filter': self.egress_filter,
 5700            'endpoint': self.endpoint,
 5701            'healthcheck_namespace': self.healthcheck_namespace,
 5702            'healthy': self.healthy,
 5703            'id': self.id,
 5704            'name': self.name,
 5705            'remote_identity_group_id': self.remote_identity_group_id,
 5706            'remote_identity_healthcheck_username':
 5707            self.remote_identity_healthcheck_username,
 5708            'secret_store_id': self.secret_store_id,
 5709            'service_account_key': self.service_account_key,
 5710            'tags': self.tags,
 5711        }
 5712
 5713    @classmethod
 5714    def from_dict(cls, d):
 5715        return cls(
 5716            bind_interface=d.get('bind_interface'),
 5717            certificate_authority=d.get('certificate_authority'),
 5718            egress_filter=d.get('egress_filter'),
 5719            endpoint=d.get('endpoint'),
 5720            healthcheck_namespace=d.get('healthcheck_namespace'),
 5721            healthy=d.get('healthy'),
 5722            id=d.get('id'),
 5723            name=d.get('name'),
 5724            remote_identity_group_id=d.get('remote_identity_group_id'),
 5725            remote_identity_healthcheck_username=d.get(
 5726                'remote_identity_healthcheck_username'),
 5727            secret_store_id=d.get('secret_store_id'),
 5728            service_account_key=d.get('service_account_key'),
 5729            tags=d.get('tags'),
 5730        )
 5731
 5732
 5733class GoogleGKEUserImpersonation:
 5734    __slots__ = [
 5735        'bind_interface',
 5736        'certificate_authority',
 5737        'egress_filter',
 5738        'endpoint',
 5739        'healthcheck_namespace',
 5740        'healthy',
 5741        'id',
 5742        'name',
 5743        'secret_store_id',
 5744        'service_account_key',
 5745        'tags',
 5746    ]
 5747
 5748    def __init__(
 5749        self,
 5750        bind_interface=None,
 5751        certificate_authority=None,
 5752        egress_filter=None,
 5753        endpoint=None,
 5754        healthcheck_namespace=None,
 5755        healthy=None,
 5756        id=None,
 5757        name=None,
 5758        secret_store_id=None,
 5759        service_account_key=None,
 5760        tags=None,
 5761    ):
 5762        self.bind_interface = bind_interface if bind_interface is not None else ''
 5763        '''
 5764         Bind interface
 5765        '''
 5766        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5767        self.egress_filter = egress_filter if egress_filter is not None else ''
 5768        '''
 5769         A filter applied to the routing logic to pin datasource to nodes.
 5770        '''
 5771        self.endpoint = endpoint if endpoint is not None else ''
 5772        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5773        '''
 5774         The path used to check the health of your connection.  Defaults to `default`.
 5775        '''
 5776        self.healthy = healthy if healthy is not None else False
 5777        '''
 5778         True if the datasource is reachable and the credentials are valid.
 5779        '''
 5780        self.id = id if id is not None else ''
 5781        '''
 5782         Unique identifier of the Resource.
 5783        '''
 5784        self.name = name if name is not None else ''
 5785        '''
 5786         Unique human-readable name of the Resource.
 5787        '''
 5788        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5789        '''
 5790         ID of the secret store containing credentials for this resource, if any.
 5791        '''
 5792        self.service_account_key = service_account_key if service_account_key is not None else ''
 5793        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5794        '''
 5795         Tags is a map of key, value pairs.
 5796        '''
 5797
 5798    def __repr__(self):
 5799        return '<sdm.GoogleGKEUserImpersonation ' + \
 5800            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5801            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5802            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5803            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5804            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5805            'healthy: ' + repr(self.healthy) + ' ' +\
 5806            'id: ' + repr(self.id) + ' ' +\
 5807            'name: ' + repr(self.name) + ' ' +\
 5808            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5809            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5810            'tags: ' + repr(self.tags) + ' ' +\
 5811            '>'
 5812
 5813    def to_dict(self):
 5814        return {
 5815            'bind_interface': self.bind_interface,
 5816            'certificate_authority': self.certificate_authority,
 5817            'egress_filter': self.egress_filter,
 5818            'endpoint': self.endpoint,
 5819            'healthcheck_namespace': self.healthcheck_namespace,
 5820            'healthy': self.healthy,
 5821            'id': self.id,
 5822            'name': self.name,
 5823            'secret_store_id': self.secret_store_id,
 5824            'service_account_key': self.service_account_key,
 5825            'tags': self.tags,
 5826        }
 5827
 5828    @classmethod
 5829    def from_dict(cls, d):
 5830        return cls(
 5831            bind_interface=d.get('bind_interface'),
 5832            certificate_authority=d.get('certificate_authority'),
 5833            egress_filter=d.get('egress_filter'),
 5834            endpoint=d.get('endpoint'),
 5835            healthcheck_namespace=d.get('healthcheck_namespace'),
 5836            healthy=d.get('healthy'),
 5837            id=d.get('id'),
 5838            name=d.get('name'),
 5839            secret_store_id=d.get('secret_store_id'),
 5840            service_account_key=d.get('service_account_key'),
 5841            tags=d.get('tags'),
 5842        )
 5843
 5844
 5845class Greenplum:
 5846    __slots__ = [
 5847        'bind_interface',
 5848        'database',
 5849        'egress_filter',
 5850        'healthy',
 5851        'hostname',
 5852        'id',
 5853        'name',
 5854        'override_database',
 5855        'password',
 5856        'port',
 5857        'port_override',
 5858        'secret_store_id',
 5859        'tags',
 5860        'username',
 5861    ]
 5862
 5863    def __init__(
 5864        self,
 5865        bind_interface=None,
 5866        database=None,
 5867        egress_filter=None,
 5868        healthy=None,
 5869        hostname=None,
 5870        id=None,
 5871        name=None,
 5872        override_database=None,
 5873        password=None,
 5874        port=None,
 5875        port_override=None,
 5876        secret_store_id=None,
 5877        tags=None,
 5878        username=None,
 5879    ):
 5880        self.bind_interface = bind_interface if bind_interface is not None else ''
 5881        '''
 5882         Bind interface
 5883        '''
 5884        self.database = database if database is not None else ''
 5885        self.egress_filter = egress_filter if egress_filter is not None else ''
 5886        '''
 5887         A filter applied to the routing logic to pin datasource to nodes.
 5888        '''
 5889        self.healthy = healthy if healthy is not None else False
 5890        '''
 5891         True if the datasource is reachable and the credentials are valid.
 5892        '''
 5893        self.hostname = hostname if hostname is not None else ''
 5894        self.id = id if id is not None else ''
 5895        '''
 5896         Unique identifier of the Resource.
 5897        '''
 5898        self.name = name if name is not None else ''
 5899        '''
 5900         Unique human-readable name of the Resource.
 5901        '''
 5902        self.override_database = override_database if override_database is not None else False
 5903        self.password = password if password is not None else ''
 5904        self.port = port if port is not None else 0
 5905        self.port_override = port_override if port_override is not None else 0
 5906        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5907        '''
 5908         ID of the secret store containing credentials for this resource, if any.
 5909        '''
 5910        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5911        '''
 5912         Tags is a map of key, value pairs.
 5913        '''
 5914        self.username = username if username is not None else ''
 5915
 5916    def __repr__(self):
 5917        return '<sdm.Greenplum ' + \
 5918            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5919            'database: ' + repr(self.database) + ' ' +\
 5920            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5921            'healthy: ' + repr(self.healthy) + ' ' +\
 5922            'hostname: ' + repr(self.hostname) + ' ' +\
 5923            'id: ' + repr(self.id) + ' ' +\
 5924            'name: ' + repr(self.name) + ' ' +\
 5925            'override_database: ' + repr(self.override_database) + ' ' +\
 5926            'password: ' + repr(self.password) + ' ' +\
 5927            'port: ' + repr(self.port) + ' ' +\
 5928            'port_override: ' + repr(self.port_override) + ' ' +\
 5929            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5930            'tags: ' + repr(self.tags) + ' ' +\
 5931            'username: ' + repr(self.username) + ' ' +\
 5932            '>'
 5933
 5934    def to_dict(self):
 5935        return {
 5936            'bind_interface': self.bind_interface,
 5937            'database': self.database,
 5938            'egress_filter': self.egress_filter,
 5939            'healthy': self.healthy,
 5940            'hostname': self.hostname,
 5941            'id': self.id,
 5942            'name': self.name,
 5943            'override_database': self.override_database,
 5944            'password': self.password,
 5945            'port': self.port,
 5946            'port_override': self.port_override,
 5947            'secret_store_id': self.secret_store_id,
 5948            'tags': self.tags,
 5949            'username': self.username,
 5950        }
 5951
 5952    @classmethod
 5953    def from_dict(cls, d):
 5954        return cls(
 5955            bind_interface=d.get('bind_interface'),
 5956            database=d.get('database'),
 5957            egress_filter=d.get('egress_filter'),
 5958            healthy=d.get('healthy'),
 5959            hostname=d.get('hostname'),
 5960            id=d.get('id'),
 5961            name=d.get('name'),
 5962            override_database=d.get('override_database'),
 5963            password=d.get('password'),
 5964            port=d.get('port'),
 5965            port_override=d.get('port_override'),
 5966            secret_store_id=d.get('secret_store_id'),
 5967            tags=d.get('tags'),
 5968            username=d.get('username'),
 5969        )
 5970
 5971
 5972class HTTPAuth:
 5973    __slots__ = [
 5974        'auth_header',
 5975        'bind_interface',
 5976        'default_path',
 5977        'egress_filter',
 5978        'headers_blacklist',
 5979        'healthcheck_path',
 5980        'healthy',
 5981        'host_override',
 5982        'id',
 5983        'name',
 5984        'secret_store_id',
 5985        'subdomain',
 5986        'tags',
 5987        'url',
 5988    ]
 5989
 5990    def __init__(
 5991        self,
 5992        auth_header=None,
 5993        bind_interface=None,
 5994        default_path=None,
 5995        egress_filter=None,
 5996        headers_blacklist=None,
 5997        healthcheck_path=None,
 5998        healthy=None,
 5999        host_override=None,
 6000        id=None,
 6001        name=None,
 6002        secret_store_id=None,
 6003        subdomain=None,
 6004        tags=None,
 6005        url=None,
 6006    ):
 6007        self.auth_header = auth_header if auth_header is not None else ''
 6008        self.bind_interface = bind_interface if bind_interface is not None else ''
 6009        '''
 6010         Bind interface
 6011        '''
 6012        self.default_path = default_path if default_path is not None else ''
 6013        self.egress_filter = egress_filter if egress_filter is not None else ''
 6014        '''
 6015         A filter applied to the routing logic to pin datasource to nodes.
 6016        '''
 6017        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6018        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6019        self.healthy = healthy if healthy is not None else False
 6020        '''
 6021         True if the datasource is reachable and the credentials are valid.
 6022        '''
 6023        self.host_override = host_override if host_override is not None else ''
 6024        self.id = id if id is not None else ''
 6025        '''
 6026         Unique identifier of the Resource.
 6027        '''
 6028        self.name = name if name is not None else ''
 6029        '''
 6030         Unique human-readable name of the Resource.
 6031        '''
 6032        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6033        '''
 6034         ID of the secret store containing credentials for this resource, if any.
 6035        '''
 6036        self.subdomain = subdomain if subdomain is not None else ''
 6037        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6038        '''
 6039         Tags is a map of key, value pairs.
 6040        '''
 6041        self.url = url if url is not None else ''
 6042
 6043    def __repr__(self):
 6044        return '<sdm.HTTPAuth ' + \
 6045            'auth_header: ' + repr(self.auth_header) + ' ' +\
 6046            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6047            'default_path: ' + repr(self.default_path) + ' ' +\
 6048            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6049            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6050            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6051            'healthy: ' + repr(self.healthy) + ' ' +\
 6052            'host_override: ' + repr(self.host_override) + ' ' +\
 6053            'id: ' + repr(self.id) + ' ' +\
 6054            'name: ' + repr(self.name) + ' ' +\
 6055            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6056            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6057            'tags: ' + repr(self.tags) + ' ' +\
 6058            'url: ' + repr(self.url) + ' ' +\
 6059            '>'
 6060
 6061    def to_dict(self):
 6062        return {
 6063            'auth_header': self.auth_header,
 6064            'bind_interface': self.bind_interface,
 6065            'default_path': self.default_path,
 6066            'egress_filter': self.egress_filter,
 6067            'headers_blacklist': self.headers_blacklist,
 6068            'healthcheck_path': self.healthcheck_path,
 6069            'healthy': self.healthy,
 6070            'host_override': self.host_override,
 6071            'id': self.id,
 6072            'name': self.name,
 6073            'secret_store_id': self.secret_store_id,
 6074            'subdomain': self.subdomain,
 6075            'tags': self.tags,
 6076            'url': self.url,
 6077        }
 6078
 6079    @classmethod
 6080    def from_dict(cls, d):
 6081        return cls(
 6082            auth_header=d.get('auth_header'),
 6083            bind_interface=d.get('bind_interface'),
 6084            default_path=d.get('default_path'),
 6085            egress_filter=d.get('egress_filter'),
 6086            headers_blacklist=d.get('headers_blacklist'),
 6087            healthcheck_path=d.get('healthcheck_path'),
 6088            healthy=d.get('healthy'),
 6089            host_override=d.get('host_override'),
 6090            id=d.get('id'),
 6091            name=d.get('name'),
 6092            secret_store_id=d.get('secret_store_id'),
 6093            subdomain=d.get('subdomain'),
 6094            tags=d.get('tags'),
 6095            url=d.get('url'),
 6096        )
 6097
 6098
 6099class HTTPBasicAuth:
 6100    __slots__ = [
 6101        'bind_interface',
 6102        'default_path',
 6103        'egress_filter',
 6104        'headers_blacklist',
 6105        'healthcheck_path',
 6106        'healthy',
 6107        'host_override',
 6108        'id',
 6109        'name',
 6110        'password',
 6111        'secret_store_id',
 6112        'subdomain',
 6113        'tags',
 6114        'url',
 6115        'username',
 6116    ]
 6117
 6118    def __init__(
 6119        self,
 6120        bind_interface=None,
 6121        default_path=None,
 6122        egress_filter=None,
 6123        headers_blacklist=None,
 6124        healthcheck_path=None,
 6125        healthy=None,
 6126        host_override=None,
 6127        id=None,
 6128        name=None,
 6129        password=None,
 6130        secret_store_id=None,
 6131        subdomain=None,
 6132        tags=None,
 6133        url=None,
 6134        username=None,
 6135    ):
 6136        self.bind_interface = bind_interface if bind_interface is not None else ''
 6137        '''
 6138         Bind interface
 6139        '''
 6140        self.default_path = default_path if default_path is not None else ''
 6141        self.egress_filter = egress_filter if egress_filter is not None else ''
 6142        '''
 6143         A filter applied to the routing logic to pin datasource to nodes.
 6144        '''
 6145        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6146        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6147        self.healthy = healthy if healthy is not None else False
 6148        '''
 6149         True if the datasource is reachable and the credentials are valid.
 6150        '''
 6151        self.host_override = host_override if host_override is not None else ''
 6152        self.id = id if id is not None else ''
 6153        '''
 6154         Unique identifier of the Resource.
 6155        '''
 6156        self.name = name if name is not None else ''
 6157        '''
 6158         Unique human-readable name of the Resource.
 6159        '''
 6160        self.password = password if password is not None else ''
 6161        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6162        '''
 6163         ID of the secret store containing credentials for this resource, if any.
 6164        '''
 6165        self.subdomain = subdomain if subdomain is not None else ''
 6166        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6167        '''
 6168         Tags is a map of key, value pairs.
 6169        '''
 6170        self.url = url if url is not None else ''
 6171        self.username = username if username is not None else ''
 6172
 6173    def __repr__(self):
 6174        return '<sdm.HTTPBasicAuth ' + \
 6175            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6176            'default_path: ' + repr(self.default_path) + ' ' +\
 6177            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6178            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6179            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6180            'healthy: ' + repr(self.healthy) + ' ' +\
 6181            'host_override: ' + repr(self.host_override) + ' ' +\
 6182            'id: ' + repr(self.id) + ' ' +\
 6183            'name: ' + repr(self.name) + ' ' +\
 6184            'password: ' + repr(self.password) + ' ' +\
 6185            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6186            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6187            'tags: ' + repr(self.tags) + ' ' +\
 6188            'url: ' + repr(self.url) + ' ' +\
 6189            'username: ' + repr(self.username) + ' ' +\
 6190            '>'
 6191
 6192    def to_dict(self):
 6193        return {
 6194            'bind_interface': self.bind_interface,
 6195            'default_path': self.default_path,
 6196            'egress_filter': self.egress_filter,
 6197            'headers_blacklist': self.headers_blacklist,
 6198            'healthcheck_path': self.healthcheck_path,
 6199            'healthy': self.healthy,
 6200            'host_override': self.host_override,
 6201            'id': self.id,
 6202            'name': self.name,
 6203            'password': self.password,
 6204            'secret_store_id': self.secret_store_id,
 6205            'subdomain': self.subdomain,
 6206            'tags': self.tags,
 6207            'url': self.url,
 6208            'username': self.username,
 6209        }
 6210
 6211    @classmethod
 6212    def from_dict(cls, d):
 6213        return cls(
 6214            bind_interface=d.get('bind_interface'),
 6215            default_path=d.get('default_path'),
 6216            egress_filter=d.get('egress_filter'),
 6217            headers_blacklist=d.get('headers_blacklist'),
 6218            healthcheck_path=d.get('healthcheck_path'),
 6219            healthy=d.get('healthy'),
 6220            host_override=d.get('host_override'),
 6221            id=d.get('id'),
 6222            name=d.get('name'),
 6223            password=d.get('password'),
 6224            secret_store_id=d.get('secret_store_id'),
 6225            subdomain=d.get('subdomain'),
 6226            tags=d.get('tags'),
 6227            url=d.get('url'),
 6228            username=d.get('username'),
 6229        )
 6230
 6231
 6232class HTTPNoAuth:
 6233    __slots__ = [
 6234        'bind_interface',
 6235        'default_path',
 6236        'egress_filter',
 6237        'headers_blacklist',
 6238        'healthcheck_path',
 6239        'healthy',
 6240        'host_override',
 6241        'id',
 6242        'name',
 6243        'secret_store_id',
 6244        'subdomain',
 6245        'tags',
 6246        'url',
 6247    ]
 6248
 6249    def __init__(
 6250        self,
 6251        bind_interface=None,
 6252        default_path=None,
 6253        egress_filter=None,
 6254        headers_blacklist=None,
 6255        healthcheck_path=None,
 6256        healthy=None,
 6257        host_override=None,
 6258        id=None,
 6259        name=None,
 6260        secret_store_id=None,
 6261        subdomain=None,
 6262        tags=None,
 6263        url=None,
 6264    ):
 6265        self.bind_interface = bind_interface if bind_interface is not None else ''
 6266        '''
 6267         Bind interface
 6268        '''
 6269        self.default_path = default_path if default_path is not None else ''
 6270        self.egress_filter = egress_filter if egress_filter is not None else ''
 6271        '''
 6272         A filter applied to the routing logic to pin datasource to nodes.
 6273        '''
 6274        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6275        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6276        self.healthy = healthy if healthy is not None else False
 6277        '''
 6278         True if the datasource is reachable and the credentials are valid.
 6279        '''
 6280        self.host_override = host_override if host_override is not None else ''
 6281        self.id = id if id is not None else ''
 6282        '''
 6283         Unique identifier of the Resource.
 6284        '''
 6285        self.name = name if name is not None else ''
 6286        '''
 6287         Unique human-readable name of the Resource.
 6288        '''
 6289        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6290        '''
 6291         ID of the secret store containing credentials for this resource, if any.
 6292        '''
 6293        self.subdomain = subdomain if subdomain is not None else ''
 6294        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6295        '''
 6296         Tags is a map of key, value pairs.
 6297        '''
 6298        self.url = url if url is not None else ''
 6299
 6300    def __repr__(self):
 6301        return '<sdm.HTTPNoAuth ' + \
 6302            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6303            'default_path: ' + repr(self.default_path) + ' ' +\
 6304            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6305            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6306            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6307            'healthy: ' + repr(self.healthy) + ' ' +\
 6308            'host_override: ' + repr(self.host_override) + ' ' +\
 6309            'id: ' + repr(self.id) + ' ' +\
 6310            'name: ' + repr(self.name) + ' ' +\
 6311            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6312            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6313            'tags: ' + repr(self.tags) + ' ' +\
 6314            'url: ' + repr(self.url) + ' ' +\
 6315            '>'
 6316
 6317    def to_dict(self):
 6318        return {
 6319            'bind_interface': self.bind_interface,
 6320            'default_path': self.default_path,
 6321            'egress_filter': self.egress_filter,
 6322            'headers_blacklist': self.headers_blacklist,
 6323            'healthcheck_path': self.healthcheck_path,
 6324            'healthy': self.healthy,
 6325            'host_override': self.host_override,
 6326            'id': self.id,
 6327            'name': self.name,
 6328            'secret_store_id': self.secret_store_id,
 6329            'subdomain': self.subdomain,
 6330            'tags': self.tags,
 6331            'url': self.url,
 6332        }
 6333
 6334    @classmethod
 6335    def from_dict(cls, d):
 6336        return cls(
 6337            bind_interface=d.get('bind_interface'),
 6338            default_path=d.get('default_path'),
 6339            egress_filter=d.get('egress_filter'),
 6340            headers_blacklist=d.get('headers_blacklist'),
 6341            healthcheck_path=d.get('healthcheck_path'),
 6342            healthy=d.get('healthy'),
 6343            host_override=d.get('host_override'),
 6344            id=d.get('id'),
 6345            name=d.get('name'),
 6346            secret_store_id=d.get('secret_store_id'),
 6347            subdomain=d.get('subdomain'),
 6348            tags=d.get('tags'),
 6349            url=d.get('url'),
 6350        )
 6351
 6352
 6353class Kubernetes:
 6354    __slots__ = [
 6355        'bind_interface',
 6356        'certificate_authority',
 6357        'client_certificate',
 6358        'client_key',
 6359        'egress_filter',
 6360        'healthcheck_namespace',
 6361        'healthy',
 6362        'hostname',
 6363        'id',
 6364        'name',
 6365        'port',
 6366        'port_override',
 6367        'remote_identity_group_id',
 6368        'remote_identity_healthcheck_username',
 6369        'secret_store_id',
 6370        'tags',
 6371    ]
 6372
 6373    def __init__(
 6374        self,
 6375        bind_interface=None,
 6376        certificate_authority=None,
 6377        client_certificate=None,
 6378        client_key=None,
 6379        egress_filter=None,
 6380        healthcheck_namespace=None,
 6381        healthy=None,
 6382        hostname=None,
 6383        id=None,
 6384        name=None,
 6385        port=None,
 6386        port_override=None,
 6387        remote_identity_group_id=None,
 6388        remote_identity_healthcheck_username=None,
 6389        secret_store_id=None,
 6390        tags=None,
 6391    ):
 6392        self.bind_interface = bind_interface if bind_interface is not None else ''
 6393        '''
 6394         Bind interface
 6395        '''
 6396        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6397        self.client_certificate = client_certificate if client_certificate is not None else ''
 6398        self.client_key = client_key if client_key is not None else ''
 6399        self.egress_filter = egress_filter if egress_filter is not None else ''
 6400        '''
 6401         A filter applied to the routing logic to pin datasource to nodes.
 6402        '''
 6403        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6404        '''
 6405         The path used to check the health of your connection.  Defaults to `default`.
 6406        '''
 6407        self.healthy = healthy if healthy is not None else False
 6408        '''
 6409         True if the datasource is reachable and the credentials are valid.
 6410        '''
 6411        self.hostname = hostname if hostname is not None else ''
 6412        self.id = id if id is not None else ''
 6413        '''
 6414         Unique identifier of the Resource.
 6415        '''
 6416        self.name = name if name is not None else ''
 6417        '''
 6418         Unique human-readable name of the Resource.
 6419        '''
 6420        self.port = port if port is not None else 0
 6421        self.port_override = port_override if port_override is not None else 0
 6422        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6423        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6424        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6425        '''
 6426         ID of the secret store containing credentials for this resource, if any.
 6427        '''
 6428        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6429        '''
 6430         Tags is a map of key, value pairs.
 6431        '''
 6432
 6433    def __repr__(self):
 6434        return '<sdm.Kubernetes ' + \
 6435            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6436            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6437            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6438            'client_key: ' + repr(self.client_key) + ' ' +\
 6439            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6440            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6441            'healthy: ' + repr(self.healthy) + ' ' +\
 6442            'hostname: ' + repr(self.hostname) + ' ' +\
 6443            'id: ' + repr(self.id) + ' ' +\
 6444            'name: ' + repr(self.name) + ' ' +\
 6445            'port: ' + repr(self.port) + ' ' +\
 6446            'port_override: ' + repr(self.port_override) + ' ' +\
 6447            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6448            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6449            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6450            'tags: ' + repr(self.tags) + ' ' +\
 6451            '>'
 6452
 6453    def to_dict(self):
 6454        return {
 6455            'bind_interface': self.bind_interface,
 6456            'certificate_authority': self.certificate_authority,
 6457            'client_certificate': self.client_certificate,
 6458            'client_key': self.client_key,
 6459            'egress_filter': self.egress_filter,
 6460            'healthcheck_namespace': self.healthcheck_namespace,
 6461            'healthy': self.healthy,
 6462            'hostname': self.hostname,
 6463            'id': self.id,
 6464            'name': self.name,
 6465            'port': self.port,
 6466            'port_override': self.port_override,
 6467            'remote_identity_group_id': self.remote_identity_group_id,
 6468            'remote_identity_healthcheck_username':
 6469            self.remote_identity_healthcheck_username,
 6470            'secret_store_id': self.secret_store_id,
 6471            'tags': self.tags,
 6472        }
 6473
 6474    @classmethod
 6475    def from_dict(cls, d):
 6476        return cls(
 6477            bind_interface=d.get('bind_interface'),
 6478            certificate_authority=d.get('certificate_authority'),
 6479            client_certificate=d.get('client_certificate'),
 6480            client_key=d.get('client_key'),
 6481            egress_filter=d.get('egress_filter'),
 6482            healthcheck_namespace=d.get('healthcheck_namespace'),
 6483            healthy=d.get('healthy'),
 6484            hostname=d.get('hostname'),
 6485            id=d.get('id'),
 6486            name=d.get('name'),
 6487            port=d.get('port'),
 6488            port_override=d.get('port_override'),
 6489            remote_identity_group_id=d.get('remote_identity_group_id'),
 6490            remote_identity_healthcheck_username=d.get(
 6491                'remote_identity_healthcheck_username'),
 6492            secret_store_id=d.get('secret_store_id'),
 6493            tags=d.get('tags'),
 6494        )
 6495
 6496
 6497class KubernetesBasicAuth:
 6498    __slots__ = [
 6499        'bind_interface',
 6500        'egress_filter',
 6501        'healthcheck_namespace',
 6502        'healthy',
 6503        'hostname',
 6504        'id',
 6505        'name',
 6506        'password',
 6507        'port',
 6508        'port_override',
 6509        'secret_store_id',
 6510        'tags',
 6511        'username',
 6512    ]
 6513
 6514    def __init__(
 6515        self,
 6516        bind_interface=None,
 6517        egress_filter=None,
 6518        healthcheck_namespace=None,
 6519        healthy=None,
 6520        hostname=None,
 6521        id=None,
 6522        name=None,
 6523        password=None,
 6524        port=None,
 6525        port_override=None,
 6526        secret_store_id=None,
 6527        tags=None,
 6528        username=None,
 6529    ):
 6530        self.bind_interface = bind_interface if bind_interface is not None else ''
 6531        '''
 6532         Bind interface
 6533        '''
 6534        self.egress_filter = egress_filter if egress_filter is not None else ''
 6535        '''
 6536         A filter applied to the routing logic to pin datasource to nodes.
 6537        '''
 6538        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6539        '''
 6540         The path used to check the health of your connection.  Defaults to `default`.
 6541        '''
 6542        self.healthy = healthy if healthy is not None else False
 6543        '''
 6544         True if the datasource is reachable and the credentials are valid.
 6545        '''
 6546        self.hostname = hostname if hostname is not None else ''
 6547        self.id = id if id is not None else ''
 6548        '''
 6549         Unique identifier of the Resource.
 6550        '''
 6551        self.name = name if name is not None else ''
 6552        '''
 6553         Unique human-readable name of the Resource.
 6554        '''
 6555        self.password = password if password is not None else ''
 6556        self.port = port if port is not None else 0
 6557        self.port_override = port_override if port_override is not None else 0
 6558        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6559        '''
 6560         ID of the secret store containing credentials for this resource, if any.
 6561        '''
 6562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6563        '''
 6564         Tags is a map of key, value pairs.
 6565        '''
 6566        self.username = username if username is not None else ''
 6567
 6568    def __repr__(self):
 6569        return '<sdm.KubernetesBasicAuth ' + \
 6570            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6571            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6572            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6573            'healthy: ' + repr(self.healthy) + ' ' +\
 6574            'hostname: ' + repr(self.hostname) + ' ' +\
 6575            'id: ' + repr(self.id) + ' ' +\
 6576            'name: ' + repr(self.name) + ' ' +\
 6577            'password: ' + repr(self.password) + ' ' +\
 6578            'port: ' + repr(self.port) + ' ' +\
 6579            'port_override: ' + repr(self.port_override) + ' ' +\
 6580            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6581            'tags: ' + repr(self.tags) + ' ' +\
 6582            'username: ' + repr(self.username) + ' ' +\
 6583            '>'
 6584
 6585    def to_dict(self):
 6586        return {
 6587            'bind_interface': self.bind_interface,
 6588            'egress_filter': self.egress_filter,
 6589            'healthcheck_namespace': self.healthcheck_namespace,
 6590            'healthy': self.healthy,
 6591            'hostname': self.hostname,
 6592            'id': self.id,
 6593            'name': self.name,
 6594            'password': self.password,
 6595            'port': self.port,
 6596            'port_override': self.port_override,
 6597            'secret_store_id': self.secret_store_id,
 6598            'tags': self.tags,
 6599            'username': self.username,
 6600        }
 6601
 6602    @classmethod
 6603    def from_dict(cls, d):
 6604        return cls(
 6605            bind_interface=d.get('bind_interface'),
 6606            egress_filter=d.get('egress_filter'),
 6607            healthcheck_namespace=d.get('healthcheck_namespace'),
 6608            healthy=d.get('healthy'),
 6609            hostname=d.get('hostname'),
 6610            id=d.get('id'),
 6611            name=d.get('name'),
 6612            password=d.get('password'),
 6613            port=d.get('port'),
 6614            port_override=d.get('port_override'),
 6615            secret_store_id=d.get('secret_store_id'),
 6616            tags=d.get('tags'),
 6617            username=d.get('username'),
 6618        )
 6619
 6620
 6621class KubernetesServiceAccount:
 6622    __slots__ = [
 6623        'bind_interface',
 6624        'egress_filter',
 6625        'healthcheck_namespace',
 6626        'healthy',
 6627        'hostname',
 6628        'id',
 6629        'name',
 6630        'port',
 6631        'port_override',
 6632        'remote_identity_group_id',
 6633        'remote_identity_healthcheck_username',
 6634        'secret_store_id',
 6635        'tags',
 6636        'token',
 6637    ]
 6638
 6639    def __init__(
 6640        self,
 6641        bind_interface=None,
 6642        egress_filter=None,
 6643        healthcheck_namespace=None,
 6644        healthy=None,
 6645        hostname=None,
 6646        id=None,
 6647        name=None,
 6648        port=None,
 6649        port_override=None,
 6650        remote_identity_group_id=None,
 6651        remote_identity_healthcheck_username=None,
 6652        secret_store_id=None,
 6653        tags=None,
 6654        token=None,
 6655    ):
 6656        self.bind_interface = bind_interface if bind_interface is not None else ''
 6657        '''
 6658         Bind interface
 6659        '''
 6660        self.egress_filter = egress_filter if egress_filter is not None else ''
 6661        '''
 6662         A filter applied to the routing logic to pin datasource to nodes.
 6663        '''
 6664        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6665        '''
 6666         The path used to check the health of your connection.  Defaults to `default`.
 6667        '''
 6668        self.healthy = healthy if healthy is not None else False
 6669        '''
 6670         True if the datasource is reachable and the credentials are valid.
 6671        '''
 6672        self.hostname = hostname if hostname is not None else ''
 6673        self.id = id if id is not None else ''
 6674        '''
 6675         Unique identifier of the Resource.
 6676        '''
 6677        self.name = name if name is not None else ''
 6678        '''
 6679         Unique human-readable name of the Resource.
 6680        '''
 6681        self.port = port if port is not None else 0
 6682        self.port_override = port_override if port_override is not None else 0
 6683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6684        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6685        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6686        '''
 6687         ID of the secret store containing credentials for this resource, if any.
 6688        '''
 6689        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6690        '''
 6691         Tags is a map of key, value pairs.
 6692        '''
 6693        self.token = token if token is not None else ''
 6694
 6695    def __repr__(self):
 6696        return '<sdm.KubernetesServiceAccount ' + \
 6697            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6698            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6699            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6700            'healthy: ' + repr(self.healthy) + ' ' +\
 6701            'hostname: ' + repr(self.hostname) + ' ' +\
 6702            'id: ' + repr(self.id) + ' ' +\
 6703            'name: ' + repr(self.name) + ' ' +\
 6704            'port: ' + repr(self.port) + ' ' +\
 6705            'port_override: ' + repr(self.port_override) + ' ' +\
 6706            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6707            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6708            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6709            'tags: ' + repr(self.tags) + ' ' +\
 6710            'token: ' + repr(self.token) + ' ' +\
 6711            '>'
 6712
 6713    def to_dict(self):
 6714        return {
 6715            'bind_interface': self.bind_interface,
 6716            'egress_filter': self.egress_filter,
 6717            'healthcheck_namespace': self.healthcheck_namespace,
 6718            'healthy': self.healthy,
 6719            'hostname': self.hostname,
 6720            'id': self.id,
 6721            'name': self.name,
 6722            'port': self.port,
 6723            'port_override': self.port_override,
 6724            'remote_identity_group_id': self.remote_identity_group_id,
 6725            'remote_identity_healthcheck_username':
 6726            self.remote_identity_healthcheck_username,
 6727            'secret_store_id': self.secret_store_id,
 6728            'tags': self.tags,
 6729            'token': self.token,
 6730        }
 6731
 6732    @classmethod
 6733    def from_dict(cls, d):
 6734        return cls(
 6735            bind_interface=d.get('bind_interface'),
 6736            egress_filter=d.get('egress_filter'),
 6737            healthcheck_namespace=d.get('healthcheck_namespace'),
 6738            healthy=d.get('healthy'),
 6739            hostname=d.get('hostname'),
 6740            id=d.get('id'),
 6741            name=d.get('name'),
 6742            port=d.get('port'),
 6743            port_override=d.get('port_override'),
 6744            remote_identity_group_id=d.get('remote_identity_group_id'),
 6745            remote_identity_healthcheck_username=d.get(
 6746                'remote_identity_healthcheck_username'),
 6747            secret_store_id=d.get('secret_store_id'),
 6748            tags=d.get('tags'),
 6749            token=d.get('token'),
 6750        )
 6751
 6752
 6753class KubernetesServiceAccountUserImpersonation:
 6754    __slots__ = [
 6755        'bind_interface',
 6756        'egress_filter',
 6757        'healthcheck_namespace',
 6758        'healthy',
 6759        'hostname',
 6760        'id',
 6761        'name',
 6762        'port',
 6763        'port_override',
 6764        'secret_store_id',
 6765        'tags',
 6766        'token',
 6767    ]
 6768
 6769    def __init__(
 6770        self,
 6771        bind_interface=None,
 6772        egress_filter=None,
 6773        healthcheck_namespace=None,
 6774        healthy=None,
 6775        hostname=None,
 6776        id=None,
 6777        name=None,
 6778        port=None,
 6779        port_override=None,
 6780        secret_store_id=None,
 6781        tags=None,
 6782        token=None,
 6783    ):
 6784        self.bind_interface = bind_interface if bind_interface is not None else ''
 6785        '''
 6786         Bind interface
 6787        '''
 6788        self.egress_filter = egress_filter if egress_filter is not None else ''
 6789        '''
 6790         A filter applied to the routing logic to pin datasource to nodes.
 6791        '''
 6792        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6793        '''
 6794         The path used to check the health of your connection.  Defaults to `default`.
 6795        '''
 6796        self.healthy = healthy if healthy is not None else False
 6797        '''
 6798         True if the datasource is reachable and the credentials are valid.
 6799        '''
 6800        self.hostname = hostname if hostname is not None else ''
 6801        self.id = id if id is not None else ''
 6802        '''
 6803         Unique identifier of the Resource.
 6804        '''
 6805        self.name = name if name is not None else ''
 6806        '''
 6807         Unique human-readable name of the Resource.
 6808        '''
 6809        self.port = port if port is not None else 0
 6810        self.port_override = port_override if port_override is not None else 0
 6811        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6812        '''
 6813         ID of the secret store containing credentials for this resource, if any.
 6814        '''
 6815        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6816        '''
 6817         Tags is a map of key, value pairs.
 6818        '''
 6819        self.token = token if token is not None else ''
 6820
 6821    def __repr__(self):
 6822        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6823            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6824            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6825            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6826            'healthy: ' + repr(self.healthy) + ' ' +\
 6827            'hostname: ' + repr(self.hostname) + ' ' +\
 6828            'id: ' + repr(self.id) + ' ' +\
 6829            'name: ' + repr(self.name) + ' ' +\
 6830            'port: ' + repr(self.port) + ' ' +\
 6831            'port_override: ' + repr(self.port_override) + ' ' +\
 6832            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6833            'tags: ' + repr(self.tags) + ' ' +\
 6834            'token: ' + repr(self.token) + ' ' +\
 6835            '>'
 6836
 6837    def to_dict(self):
 6838        return {
 6839            'bind_interface': self.bind_interface,
 6840            'egress_filter': self.egress_filter,
 6841            'healthcheck_namespace': self.healthcheck_namespace,
 6842            'healthy': self.healthy,
 6843            'hostname': self.hostname,
 6844            'id': self.id,
 6845            'name': self.name,
 6846            'port': self.port,
 6847            'port_override': self.port_override,
 6848            'secret_store_id': self.secret_store_id,
 6849            'tags': self.tags,
 6850            'token': self.token,
 6851        }
 6852
 6853    @classmethod
 6854    def from_dict(cls, d):
 6855        return cls(
 6856            bind_interface=d.get('bind_interface'),
 6857            egress_filter=d.get('egress_filter'),
 6858            healthcheck_namespace=d.get('healthcheck_namespace'),
 6859            healthy=d.get('healthy'),
 6860            hostname=d.get('hostname'),
 6861            id=d.get('id'),
 6862            name=d.get('name'),
 6863            port=d.get('port'),
 6864            port_override=d.get('port_override'),
 6865            secret_store_id=d.get('secret_store_id'),
 6866            tags=d.get('tags'),
 6867            token=d.get('token'),
 6868        )
 6869
 6870
 6871class KubernetesUserImpersonation:
 6872    __slots__ = [
 6873        'bind_interface',
 6874        'certificate_authority',
 6875        'client_certificate',
 6876        'client_key',
 6877        'egress_filter',
 6878        'healthcheck_namespace',
 6879        'healthy',
 6880        'hostname',
 6881        'id',
 6882        'name',
 6883        'port',
 6884        'port_override',
 6885        'secret_store_id',
 6886        'tags',
 6887    ]
 6888
 6889    def __init__(
 6890        self,
 6891        bind_interface=None,
 6892        certificate_authority=None,
 6893        client_certificate=None,
 6894        client_key=None,
 6895        egress_filter=None,
 6896        healthcheck_namespace=None,
 6897        healthy=None,
 6898        hostname=None,
 6899        id=None,
 6900        name=None,
 6901        port=None,
 6902        port_override=None,
 6903        secret_store_id=None,
 6904        tags=None,
 6905    ):
 6906        self.bind_interface = bind_interface if bind_interface is not None else ''
 6907        '''
 6908         Bind interface
 6909        '''
 6910        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6911        self.client_certificate = client_certificate if client_certificate is not None else ''
 6912        self.client_key = client_key if client_key is not None else ''
 6913        self.egress_filter = egress_filter if egress_filter is not None else ''
 6914        '''
 6915         A filter applied to the routing logic to pin datasource to nodes.
 6916        '''
 6917        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6918        '''
 6919         The path used to check the health of your connection.  Defaults to `default`.
 6920        '''
 6921        self.healthy = healthy if healthy is not None else False
 6922        '''
 6923         True if the datasource is reachable and the credentials are valid.
 6924        '''
 6925        self.hostname = hostname if hostname is not None else ''
 6926        self.id = id if id is not None else ''
 6927        '''
 6928         Unique identifier of the Resource.
 6929        '''
 6930        self.name = name if name is not None else ''
 6931        '''
 6932         Unique human-readable name of the Resource.
 6933        '''
 6934        self.port = port if port is not None else 0
 6935        self.port_override = port_override if port_override is not None else 0
 6936        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6937        '''
 6938         ID of the secret store containing credentials for this resource, if any.
 6939        '''
 6940        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6941        '''
 6942         Tags is a map of key, value pairs.
 6943        '''
 6944
 6945    def __repr__(self):
 6946        return '<sdm.KubernetesUserImpersonation ' + \
 6947            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6948            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6949            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6950            'client_key: ' + repr(self.client_key) + ' ' +\
 6951            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6952            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6953            'healthy: ' + repr(self.healthy) + ' ' +\
 6954            'hostname: ' + repr(self.hostname) + ' ' +\
 6955            'id: ' + repr(self.id) + ' ' +\
 6956            'name: ' + repr(self.name) + ' ' +\
 6957            'port: ' + repr(self.port) + ' ' +\
 6958            'port_override: ' + repr(self.port_override) + ' ' +\
 6959            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6960            'tags: ' + repr(self.tags) + ' ' +\
 6961            '>'
 6962
 6963    def to_dict(self):
 6964        return {
 6965            'bind_interface': self.bind_interface,
 6966            'certificate_authority': self.certificate_authority,
 6967            'client_certificate': self.client_certificate,
 6968            'client_key': self.client_key,
 6969            'egress_filter': self.egress_filter,
 6970            'healthcheck_namespace': self.healthcheck_namespace,
 6971            'healthy': self.healthy,
 6972            'hostname': self.hostname,
 6973            'id': self.id,
 6974            'name': self.name,
 6975            'port': self.port,
 6976            'port_override': self.port_override,
 6977            'secret_store_id': self.secret_store_id,
 6978            'tags': self.tags,
 6979        }
 6980
 6981    @classmethod
 6982    def from_dict(cls, d):
 6983        return cls(
 6984            bind_interface=d.get('bind_interface'),
 6985            certificate_authority=d.get('certificate_authority'),
 6986            client_certificate=d.get('client_certificate'),
 6987            client_key=d.get('client_key'),
 6988            egress_filter=d.get('egress_filter'),
 6989            healthcheck_namespace=d.get('healthcheck_namespace'),
 6990            healthy=d.get('healthy'),
 6991            hostname=d.get('hostname'),
 6992            id=d.get('id'),
 6993            name=d.get('name'),
 6994            port=d.get('port'),
 6995            port_override=d.get('port_override'),
 6996            secret_store_id=d.get('secret_store_id'),
 6997            tags=d.get('tags'),
 6998        )
 6999
 7000
 7001class MTLSMysql:
 7002    '''
 7003    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 7004    without a major version bump.
 7005    '''
 7006    __slots__ = [
 7007        'bind_interface',
 7008        'certificate_authority',
 7009        'client_certificate',
 7010        'client_key',
 7011        'database',
 7012        'egress_filter',
 7013        'healthy',
 7014        'hostname',
 7015        'id',
 7016        'name',
 7017        'password',
 7018        'port',
 7019        'port_override',
 7020        'secret_store_id',
 7021        'server_name',
 7022        'tags',
 7023        'username',
 7024    ]
 7025
 7026    def __init__(
 7027        self,
 7028        bind_interface=None,
 7029        certificate_authority=None,
 7030        client_certificate=None,
 7031        client_key=None,
 7032        database=None,
 7033        egress_filter=None,
 7034        healthy=None,
 7035        hostname=None,
 7036        id=None,
 7037        name=None,
 7038        password=None,
 7039        port=None,
 7040        port_override=None,
 7041        secret_store_id=None,
 7042        server_name=None,
 7043        tags=None,
 7044        username=None,
 7045    ):
 7046        self.bind_interface = bind_interface if bind_interface is not None else ''
 7047        '''
 7048         Bind interface
 7049        '''
 7050        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7051        self.client_certificate = client_certificate if client_certificate is not None else ''
 7052        self.client_key = client_key if client_key is not None else ''
 7053        self.database = database if database is not None else ''
 7054        self.egress_filter = egress_filter if egress_filter is not None else ''
 7055        '''
 7056         A filter applied to the routing logic to pin datasource to nodes.
 7057        '''
 7058        self.healthy = healthy if healthy is not None else False
 7059        '''
 7060         True if the datasource is reachable and the credentials are valid.
 7061        '''
 7062        self.hostname = hostname if hostname is not None else ''
 7063        self.id = id if id is not None else ''
 7064        '''
 7065         Unique identifier of the Resource.
 7066        '''
 7067        self.name = name if name is not None else ''
 7068        '''
 7069         Unique human-readable name of the Resource.
 7070        '''
 7071        self.password = password if password is not None else ''
 7072        self.port = port if port is not None else 0
 7073        self.port_override = port_override if port_override is not None else 0
 7074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7075        '''
 7076         ID of the secret store containing credentials for this resource, if any.
 7077        '''
 7078        self.server_name = server_name if server_name is not None else ''
 7079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7080        '''
 7081         Tags is a map of key, value pairs.
 7082        '''
 7083        self.username = username if username is not None else ''
 7084
 7085    def __repr__(self):
 7086        return '<sdm.MTLSMysql ' + \
 7087            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7088            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7089            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7090            'client_key: ' + repr(self.client_key) + ' ' +\
 7091            'database: ' + repr(self.database) + ' ' +\
 7092            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7093            'healthy: ' + repr(self.healthy) + ' ' +\
 7094            'hostname: ' + repr(self.hostname) + ' ' +\
 7095            'id: ' + repr(self.id) + ' ' +\
 7096            'name: ' + repr(self.name) + ' ' +\
 7097            'password: ' + repr(self.password) + ' ' +\
 7098            'port: ' + repr(self.port) + ' ' +\
 7099            'port_override: ' + repr(self.port_override) + ' ' +\
 7100            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7101            'server_name: ' + repr(self.server_name) + ' ' +\
 7102            'tags: ' + repr(self.tags) + ' ' +\
 7103            'username: ' + repr(self.username) + ' ' +\
 7104            '>'
 7105
 7106    def to_dict(self):
 7107        return {
 7108            'bind_interface': self.bind_interface,
 7109            'certificate_authority': self.certificate_authority,
 7110            'client_certificate': self.client_certificate,
 7111            'client_key': self.client_key,
 7112            'database': self.database,
 7113            'egress_filter': self.egress_filter,
 7114            'healthy': self.healthy,
 7115            'hostname': self.hostname,
 7116            'id': self.id,
 7117            'name': self.name,
 7118            'password': self.password,
 7119            'port': self.port,
 7120            'port_override': self.port_override,
 7121            'secret_store_id': self.secret_store_id,
 7122            'server_name': self.server_name,
 7123            'tags': self.tags,
 7124            'username': self.username,
 7125        }
 7126
 7127    @classmethod
 7128    def from_dict(cls, d):
 7129        return cls(
 7130            bind_interface=d.get('bind_interface'),
 7131            certificate_authority=d.get('certificate_authority'),
 7132            client_certificate=d.get('client_certificate'),
 7133            client_key=d.get('client_key'),
 7134            database=d.get('database'),
 7135            egress_filter=d.get('egress_filter'),
 7136            healthy=d.get('healthy'),
 7137            hostname=d.get('hostname'),
 7138            id=d.get('id'),
 7139            name=d.get('name'),
 7140            password=d.get('password'),
 7141            port=d.get('port'),
 7142            port_override=d.get('port_override'),
 7143            secret_store_id=d.get('secret_store_id'),
 7144            server_name=d.get('server_name'),
 7145            tags=d.get('tags'),
 7146            username=d.get('username'),
 7147        )
 7148
 7149
 7150class MTLSPostgres:
 7151    __slots__ = [
 7152        'bind_interface',
 7153        'certificate_authority',
 7154        'client_certificate',
 7155        'client_key',
 7156        'database',
 7157        'egress_filter',
 7158        'healthy',
 7159        'hostname',
 7160        'id',
 7161        'name',
 7162        'override_database',
 7163        'password',
 7164        'port',
 7165        'port_override',
 7166        'secret_store_id',
 7167        'server_name',
 7168        'tags',
 7169        'username',
 7170    ]
 7171
 7172    def __init__(
 7173        self,
 7174        bind_interface=None,
 7175        certificate_authority=None,
 7176        client_certificate=None,
 7177        client_key=None,
 7178        database=None,
 7179        egress_filter=None,
 7180        healthy=None,
 7181        hostname=None,
 7182        id=None,
 7183        name=None,
 7184        override_database=None,
 7185        password=None,
 7186        port=None,
 7187        port_override=None,
 7188        secret_store_id=None,
 7189        server_name=None,
 7190        tags=None,
 7191        username=None,
 7192    ):
 7193        self.bind_interface = bind_interface if bind_interface is not None else ''
 7194        '''
 7195         Bind interface
 7196        '''
 7197        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7198        self.client_certificate = client_certificate if client_certificate is not None else ''
 7199        self.client_key = client_key if client_key is not None else ''
 7200        self.database = database if database is not None else ''
 7201        self.egress_filter = egress_filter if egress_filter is not None else ''
 7202        '''
 7203         A filter applied to the routing logic to pin datasource to nodes.
 7204        '''
 7205        self.healthy = healthy if healthy is not None else False
 7206        '''
 7207         True if the datasource is reachable and the credentials are valid.
 7208        '''
 7209        self.hostname = hostname if hostname is not None else ''
 7210        self.id = id if id is not None else ''
 7211        '''
 7212         Unique identifier of the Resource.
 7213        '''
 7214        self.name = name if name is not None else ''
 7215        '''
 7216         Unique human-readable name of the Resource.
 7217        '''
 7218        self.override_database = override_database if override_database is not None else False
 7219        self.password = password if password is not None else ''
 7220        self.port = port if port is not None else 0
 7221        self.port_override = port_override if port_override is not None else 0
 7222        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7223        '''
 7224         ID of the secret store containing credentials for this resource, if any.
 7225        '''
 7226        self.server_name = server_name if server_name is not None else ''
 7227        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7228        '''
 7229         Tags is a map of key, value pairs.
 7230        '''
 7231        self.username = username if username is not None else ''
 7232
 7233    def __repr__(self):
 7234        return '<sdm.MTLSPostgres ' + \
 7235            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7236            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7237            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7238            'client_key: ' + repr(self.client_key) + ' ' +\
 7239            'database: ' + repr(self.database) + ' ' +\
 7240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7241            'healthy: ' + repr(self.healthy) + ' ' +\
 7242            'hostname: ' + repr(self.hostname) + ' ' +\
 7243            'id: ' + repr(self.id) + ' ' +\
 7244            'name: ' + repr(self.name) + ' ' +\
 7245            'override_database: ' + repr(self.override_database) + ' ' +\
 7246            'password: ' + repr(self.password) + ' ' +\
 7247            'port: ' + repr(self.port) + ' ' +\
 7248            'port_override: ' + repr(self.port_override) + ' ' +\
 7249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7250            'server_name: ' + repr(self.server_name) + ' ' +\
 7251            'tags: ' + repr(self.tags) + ' ' +\
 7252            'username: ' + repr(self.username) + ' ' +\
 7253            '>'
 7254
 7255    def to_dict(self):
 7256        return {
 7257            'bind_interface': self.bind_interface,
 7258            'certificate_authority': self.certificate_authority,
 7259            'client_certificate': self.client_certificate,
 7260            'client_key': self.client_key,
 7261            'database': self.database,
 7262            'egress_filter': self.egress_filter,
 7263            'healthy': self.healthy,
 7264            'hostname': self.hostname,
 7265            'id': self.id,
 7266            'name': self.name,
 7267            'override_database': self.override_database,
 7268            'password': self.password,
 7269            'port': self.port,
 7270            'port_override': self.port_override,
 7271            'secret_store_id': self.secret_store_id,
 7272            'server_name': self.server_name,
 7273            'tags': self.tags,
 7274            'username': self.username,
 7275        }
 7276
 7277    @classmethod
 7278    def from_dict(cls, d):
 7279        return cls(
 7280            bind_interface=d.get('bind_interface'),
 7281            certificate_authority=d.get('certificate_authority'),
 7282            client_certificate=d.get('client_certificate'),
 7283            client_key=d.get('client_key'),
 7284            database=d.get('database'),
 7285            egress_filter=d.get('egress_filter'),
 7286            healthy=d.get('healthy'),
 7287            hostname=d.get('hostname'),
 7288            id=d.get('id'),
 7289            name=d.get('name'),
 7290            override_database=d.get('override_database'),
 7291            password=d.get('password'),
 7292            port=d.get('port'),
 7293            port_override=d.get('port_override'),
 7294            secret_store_id=d.get('secret_store_id'),
 7295            server_name=d.get('server_name'),
 7296            tags=d.get('tags'),
 7297            username=d.get('username'),
 7298        )
 7299
 7300
 7301class Maria:
 7302    __slots__ = [
 7303        'bind_interface',
 7304        'database',
 7305        'egress_filter',
 7306        'healthy',
 7307        'hostname',
 7308        'id',
 7309        'name',
 7310        'password',
 7311        'port',
 7312        'port_override',
 7313        'secret_store_id',
 7314        'tags',
 7315        'username',
 7316    ]
 7317
 7318    def __init__(
 7319        self,
 7320        bind_interface=None,
 7321        database=None,
 7322        egress_filter=None,
 7323        healthy=None,
 7324        hostname=None,
 7325        id=None,
 7326        name=None,
 7327        password=None,
 7328        port=None,
 7329        port_override=None,
 7330        secret_store_id=None,
 7331        tags=None,
 7332        username=None,
 7333    ):
 7334        self.bind_interface = bind_interface if bind_interface is not None else ''
 7335        '''
 7336         Bind interface
 7337        '''
 7338        self.database = database if database is not None else ''
 7339        self.egress_filter = egress_filter if egress_filter is not None else ''
 7340        '''
 7341         A filter applied to the routing logic to pin datasource to nodes.
 7342        '''
 7343        self.healthy = healthy if healthy is not None else False
 7344        '''
 7345         True if the datasource is reachable and the credentials are valid.
 7346        '''
 7347        self.hostname = hostname if hostname is not None else ''
 7348        self.id = id if id is not None else ''
 7349        '''
 7350         Unique identifier of the Resource.
 7351        '''
 7352        self.name = name if name is not None else ''
 7353        '''
 7354         Unique human-readable name of the Resource.
 7355        '''
 7356        self.password = password if password is not None else ''
 7357        self.port = port if port is not None else 0
 7358        self.port_override = port_override if port_override is not None else 0
 7359        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7360        '''
 7361         ID of the secret store containing credentials for this resource, if any.
 7362        '''
 7363        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7364        '''
 7365         Tags is a map of key, value pairs.
 7366        '''
 7367        self.username = username if username is not None else ''
 7368
 7369    def __repr__(self):
 7370        return '<sdm.Maria ' + \
 7371            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7372            'database: ' + repr(self.database) + ' ' +\
 7373            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7374            'healthy: ' + repr(self.healthy) + ' ' +\
 7375            'hostname: ' + repr(self.hostname) + ' ' +\
 7376            'id: ' + repr(self.id) + ' ' +\
 7377            'name: ' + repr(self.name) + ' ' +\
 7378            'password: ' + repr(self.password) + ' ' +\
 7379            'port: ' + repr(self.port) + ' ' +\
 7380            'port_override: ' + repr(self.port_override) + ' ' +\
 7381            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7382            'tags: ' + repr(self.tags) + ' ' +\
 7383            'username: ' + repr(self.username) + ' ' +\
 7384            '>'
 7385
 7386    def to_dict(self):
 7387        return {
 7388            'bind_interface': self.bind_interface,
 7389            'database': self.database,
 7390            'egress_filter': self.egress_filter,
 7391            'healthy': self.healthy,
 7392            'hostname': self.hostname,
 7393            'id': self.id,
 7394            'name': self.name,
 7395            'password': self.password,
 7396            'port': self.port,
 7397            'port_override': self.port_override,
 7398            'secret_store_id': self.secret_store_id,
 7399            'tags': self.tags,
 7400            'username': self.username,
 7401        }
 7402
 7403    @classmethod
 7404    def from_dict(cls, d):
 7405        return cls(
 7406            bind_interface=d.get('bind_interface'),
 7407            database=d.get('database'),
 7408            egress_filter=d.get('egress_filter'),
 7409            healthy=d.get('healthy'),
 7410            hostname=d.get('hostname'),
 7411            id=d.get('id'),
 7412            name=d.get('name'),
 7413            password=d.get('password'),
 7414            port=d.get('port'),
 7415            port_override=d.get('port_override'),
 7416            secret_store_id=d.get('secret_store_id'),
 7417            tags=d.get('tags'),
 7418            username=d.get('username'),
 7419        )
 7420
 7421
 7422class Memcached:
 7423    __slots__ = [
 7424        'bind_interface',
 7425        'egress_filter',
 7426        'healthy',
 7427        'hostname',
 7428        'id',
 7429        'name',
 7430        'port',
 7431        'port_override',
 7432        'secret_store_id',
 7433        'tags',
 7434    ]
 7435
 7436    def __init__(
 7437        self,
 7438        bind_interface=None,
 7439        egress_filter=None,
 7440        healthy=None,
 7441        hostname=None,
 7442        id=None,
 7443        name=None,
 7444        port=None,
 7445        port_override=None,
 7446        secret_store_id=None,
 7447        tags=None,
 7448    ):
 7449        self.bind_interface = bind_interface if bind_interface is not None else ''
 7450        '''
 7451         Bind interface
 7452        '''
 7453        self.egress_filter = egress_filter if egress_filter is not None else ''
 7454        '''
 7455         A filter applied to the routing logic to pin datasource to nodes.
 7456        '''
 7457        self.healthy = healthy if healthy is not None else False
 7458        '''
 7459         True if the datasource is reachable and the credentials are valid.
 7460        '''
 7461        self.hostname = hostname if hostname is not None else ''
 7462        self.id = id if id is not None else ''
 7463        '''
 7464         Unique identifier of the Resource.
 7465        '''
 7466        self.name = name if name is not None else ''
 7467        '''
 7468         Unique human-readable name of the Resource.
 7469        '''
 7470        self.port = port if port is not None else 0
 7471        self.port_override = port_override if port_override is not None else 0
 7472        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7473        '''
 7474         ID of the secret store containing credentials for this resource, if any.
 7475        '''
 7476        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7477        '''
 7478         Tags is a map of key, value pairs.
 7479        '''
 7480
 7481    def __repr__(self):
 7482        return '<sdm.Memcached ' + \
 7483            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7484            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7485            'healthy: ' + repr(self.healthy) + ' ' +\
 7486            'hostname: ' + repr(self.hostname) + ' ' +\
 7487            'id: ' + repr(self.id) + ' ' +\
 7488            'name: ' + repr(self.name) + ' ' +\
 7489            'port: ' + repr(self.port) + ' ' +\
 7490            'port_override: ' + repr(self.port_override) + ' ' +\
 7491            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7492            'tags: ' + repr(self.tags) + ' ' +\
 7493            '>'
 7494
 7495    def to_dict(self):
 7496        return {
 7497            'bind_interface': self.bind_interface,
 7498            'egress_filter': self.egress_filter,
 7499            'healthy': self.healthy,
 7500            'hostname': self.hostname,
 7501            'id': self.id,
 7502            'name': self.name,
 7503            'port': self.port,
 7504            'port_override': self.port_override,
 7505            'secret_store_id': self.secret_store_id,
 7506            'tags': self.tags,
 7507        }
 7508
 7509    @classmethod
 7510    def from_dict(cls, d):
 7511        return cls(
 7512            bind_interface=d.get('bind_interface'),
 7513            egress_filter=d.get('egress_filter'),
 7514            healthy=d.get('healthy'),
 7515            hostname=d.get('hostname'),
 7516            id=d.get('id'),
 7517            name=d.get('name'),
 7518            port=d.get('port'),
 7519            port_override=d.get('port_override'),
 7520            secret_store_id=d.get('secret_store_id'),
 7521            tags=d.get('tags'),
 7522        )
 7523
 7524
 7525class Memsql:
 7526    __slots__ = [
 7527        'bind_interface',
 7528        'database',
 7529        'egress_filter',
 7530        'healthy',
 7531        'hostname',
 7532        'id',
 7533        'name',
 7534        'password',
 7535        'port',
 7536        'port_override',
 7537        'secret_store_id',
 7538        'tags',
 7539        'username',
 7540    ]
 7541
 7542    def __init__(
 7543        self,
 7544        bind_interface=None,
 7545        database=None,
 7546        egress_filter=None,
 7547        healthy=None,
 7548        hostname=None,
 7549        id=None,
 7550        name=None,
 7551        password=None,
 7552        port=None,
 7553        port_override=None,
 7554        secret_store_id=None,
 7555        tags=None,
 7556        username=None,
 7557    ):
 7558        self.bind_interface = bind_interface if bind_interface is not None else ''
 7559        '''
 7560         Bind interface
 7561        '''
 7562        self.database = database if database is not None else ''
 7563        self.egress_filter = egress_filter if egress_filter is not None else ''
 7564        '''
 7565         A filter applied to the routing logic to pin datasource to nodes.
 7566        '''
 7567        self.healthy = healthy if healthy is not None else False
 7568        '''
 7569         True if the datasource is reachable and the credentials are valid.
 7570        '''
 7571        self.hostname = hostname if hostname is not None else ''
 7572        self.id = id if id is not None else ''
 7573        '''
 7574         Unique identifier of the Resource.
 7575        '''
 7576        self.name = name if name is not None else ''
 7577        '''
 7578         Unique human-readable name of the Resource.
 7579        '''
 7580        self.password = password if password is not None else ''
 7581        self.port = port if port is not None else 0
 7582        self.port_override = port_override if port_override is not None else 0
 7583        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7584        '''
 7585         ID of the secret store containing credentials for this resource, if any.
 7586        '''
 7587        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7588        '''
 7589         Tags is a map of key, value pairs.
 7590        '''
 7591        self.username = username if username is not None else ''
 7592
 7593    def __repr__(self):
 7594        return '<sdm.Memsql ' + \
 7595            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7596            'database: ' + repr(self.database) + ' ' +\
 7597            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7598            'healthy: ' + repr(self.healthy) + ' ' +\
 7599            'hostname: ' + repr(self.hostname) + ' ' +\
 7600            'id: ' + repr(self.id) + ' ' +\
 7601            'name: ' + repr(self.name) + ' ' +\
 7602            'password: ' + repr(self.password) + ' ' +\
 7603            'port: ' + repr(self.port) + ' ' +\
 7604            'port_override: ' + repr(self.port_override) + ' ' +\
 7605            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7606            'tags: ' + repr(self.tags) + ' ' +\
 7607            'username: ' + repr(self.username) + ' ' +\
 7608            '>'
 7609
 7610    def to_dict(self):
 7611        return {
 7612            'bind_interface': self.bind_interface,
 7613            'database': self.database,
 7614            'egress_filter': self.egress_filter,
 7615            'healthy': self.healthy,
 7616            'hostname': self.hostname,
 7617            'id': self.id,
 7618            'name': self.name,
 7619            'password': self.password,
 7620            'port': self.port,
 7621            'port_override': self.port_override,
 7622            'secret_store_id': self.secret_store_id,
 7623            'tags': self.tags,
 7624            'username': self.username,
 7625        }
 7626
 7627    @classmethod
 7628    def from_dict(cls, d):
 7629        return cls(
 7630            bind_interface=d.get('bind_interface'),
 7631            database=d.get('database'),
 7632            egress_filter=d.get('egress_filter'),
 7633            healthy=d.get('healthy'),
 7634            hostname=d.get('hostname'),
 7635            id=d.get('id'),
 7636            name=d.get('name'),
 7637            password=d.get('password'),
 7638            port=d.get('port'),
 7639            port_override=d.get('port_override'),
 7640            secret_store_id=d.get('secret_store_id'),
 7641            tags=d.get('tags'),
 7642            username=d.get('username'),
 7643        )
 7644
 7645
 7646class MongoHost:
 7647    '''
 7648    MongoHost is currently unstable, and its API may change, or it may be removed,
 7649    without a major version bump.
 7650    '''
 7651    __slots__ = [
 7652        'auth_database',
 7653        'bind_interface',
 7654        'egress_filter',
 7655        'healthy',
 7656        'hostname',
 7657        'id',
 7658        'name',
 7659        'password',
 7660        'port',
 7661        'port_override',
 7662        'secret_store_id',
 7663        'tags',
 7664        'tls_required',
 7665        'username',
 7666    ]
 7667
 7668    def __init__(
 7669        self,
 7670        auth_database=None,
 7671        bind_interface=None,
 7672        egress_filter=None,
 7673        healthy=None,
 7674        hostname=None,
 7675        id=None,
 7676        name=None,
 7677        password=None,
 7678        port=None,
 7679        port_override=None,
 7680        secret_store_id=None,
 7681        tags=None,
 7682        tls_required=None,
 7683        username=None,
 7684    ):
 7685        self.auth_database = auth_database if auth_database is not None else ''
 7686        self.bind_interface = bind_interface if bind_interface is not None else ''
 7687        '''
 7688         Bind interface
 7689        '''
 7690        self.egress_filter = egress_filter if egress_filter is not None else ''
 7691        '''
 7692         A filter applied to the routing logic to pin datasource to nodes.
 7693        '''
 7694        self.healthy = healthy if healthy is not None else False
 7695        '''
 7696         True if the datasource is reachable and the credentials are valid.
 7697        '''
 7698        self.hostname = hostname if hostname is not None else ''
 7699        self.id = id if id is not None else ''
 7700        '''
 7701         Unique identifier of the Resource.
 7702        '''
 7703        self.name = name if name is not None else ''
 7704        '''
 7705         Unique human-readable name of the Resource.
 7706        '''
 7707        self.password = password if password is not None else ''
 7708        self.port = port if port is not None else 0
 7709        self.port_override = port_override if port_override is not None else 0
 7710        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7711        '''
 7712         ID of the secret store containing credentials for this resource, if any.
 7713        '''
 7714        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7715        '''
 7716         Tags is a map of key, value pairs.
 7717        '''
 7718        self.tls_required = tls_required if tls_required is not None else False
 7719        self.username = username if username is not None else ''
 7720
 7721    def __repr__(self):
 7722        return '<sdm.MongoHost ' + \
 7723            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7724            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7725            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7726            'healthy: ' + repr(self.healthy) + ' ' +\
 7727            'hostname: ' + repr(self.hostname) + ' ' +\
 7728            'id: ' + repr(self.id) + ' ' +\
 7729            'name: ' + repr(self.name) + ' ' +\
 7730            'password: ' + repr(self.password) + ' ' +\
 7731            'port: ' + repr(self.port) + ' ' +\
 7732            'port_override: ' + repr(self.port_override) + ' ' +\
 7733            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7734            'tags: ' + repr(self.tags) + ' ' +\
 7735            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7736            'username: ' + repr(self.username) + ' ' +\
 7737            '>'
 7738
 7739    def to_dict(self):
 7740        return {
 7741            'auth_database': self.auth_database,
 7742            'bind_interface': self.bind_interface,
 7743            'egress_filter': self.egress_filter,
 7744            'healthy': self.healthy,
 7745            'hostname': self.hostname,
 7746            'id': self.id,
 7747            'name': self.name,
 7748            'password': self.password,
 7749            'port': self.port,
 7750            'port_override': self.port_override,
 7751            'secret_store_id': self.secret_store_id,
 7752            'tags': self.tags,
 7753            'tls_required': self.tls_required,
 7754            'username': self.username,
 7755        }
 7756
 7757    @classmethod
 7758    def from_dict(cls, d):
 7759        return cls(
 7760            auth_database=d.get('auth_database'),
 7761            bind_interface=d.get('bind_interface'),
 7762            egress_filter=d.get('egress_filter'),
 7763            healthy=d.get('healthy'),
 7764            hostname=d.get('hostname'),
 7765            id=d.get('id'),
 7766            name=d.get('name'),
 7767            password=d.get('password'),
 7768            port=d.get('port'),
 7769            port_override=d.get('port_override'),
 7770            secret_store_id=d.get('secret_store_id'),
 7771            tags=d.get('tags'),
 7772            tls_required=d.get('tls_required'),
 7773            username=d.get('username'),
 7774        )
 7775
 7776
 7777class MongoLegacyHost:
 7778    __slots__ = [
 7779        'auth_database',
 7780        'bind_interface',
 7781        'egress_filter',
 7782        'healthy',
 7783        'hostname',
 7784        'id',
 7785        'name',
 7786        'password',
 7787        'port',
 7788        'port_override',
 7789        'replica_set',
 7790        'secret_store_id',
 7791        'tags',
 7792        'tls_required',
 7793        'username',
 7794    ]
 7795
 7796    def __init__(
 7797        self,
 7798        auth_database=None,
 7799        bind_interface=None,
 7800        egress_filter=None,
 7801        healthy=None,
 7802        hostname=None,
 7803        id=None,
 7804        name=None,
 7805        password=None,
 7806        port=None,
 7807        port_override=None,
 7808        replica_set=None,
 7809        secret_store_id=None,
 7810        tags=None,
 7811        tls_required=None,
 7812        username=None,
 7813    ):
 7814        self.auth_database = auth_database if auth_database is not None else ''
 7815        self.bind_interface = bind_interface if bind_interface is not None else ''
 7816        '''
 7817         Bind interface
 7818        '''
 7819        self.egress_filter = egress_filter if egress_filter is not None else ''
 7820        '''
 7821         A filter applied to the routing logic to pin datasource to nodes.
 7822        '''
 7823        self.healthy = healthy if healthy is not None else False
 7824        '''
 7825         True if the datasource is reachable and the credentials are valid.
 7826        '''
 7827        self.hostname = hostname if hostname is not None else ''
 7828        self.id = id if id is not None else ''
 7829        '''
 7830         Unique identifier of the Resource.
 7831        '''
 7832        self.name = name if name is not None else ''
 7833        '''
 7834         Unique human-readable name of the Resource.
 7835        '''
 7836        self.password = password if password is not None else ''
 7837        self.port = port if port is not None else 0
 7838        self.port_override = port_override if port_override is not None else 0
 7839        self.replica_set = replica_set if replica_set is not None else ''
 7840        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7841        '''
 7842         ID of the secret store containing credentials for this resource, if any.
 7843        '''
 7844        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7845        '''
 7846         Tags is a map of key, value pairs.
 7847        '''
 7848        self.tls_required = tls_required if tls_required is not None else False
 7849        self.username = username if username is not None else ''
 7850
 7851    def __repr__(self):
 7852        return '<sdm.MongoLegacyHost ' + \
 7853            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7854            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7855            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7856            'healthy: ' + repr(self.healthy) + ' ' +\
 7857            'hostname: ' + repr(self.hostname) + ' ' +\
 7858            'id: ' + repr(self.id) + ' ' +\
 7859            'name: ' + repr(self.name) + ' ' +\
 7860            'password: ' + repr(self.password) + ' ' +\
 7861            'port: ' + repr(self.port) + ' ' +\
 7862            'port_override: ' + repr(self.port_override) + ' ' +\
 7863            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7864            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7865            'tags: ' + repr(self.tags) + ' ' +\
 7866            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7867            'username: ' + repr(self.username) + ' ' +\
 7868            '>'
 7869
 7870    def to_dict(self):
 7871        return {
 7872            'auth_database': self.auth_database,
 7873            'bind_interface': self.bind_interface,
 7874            'egress_filter': self.egress_filter,
 7875            'healthy': self.healthy,
 7876            'hostname': self.hostname,
 7877            'id': self.id,
 7878            'name': self.name,
 7879            'password': self.password,
 7880            'port': self.port,
 7881            'port_override': self.port_override,
 7882            'replica_set': self.replica_set,
 7883            'secret_store_id': self.secret_store_id,
 7884            'tags': self.tags,
 7885            'tls_required': self.tls_required,
 7886            'username': self.username,
 7887        }
 7888
 7889    @classmethod
 7890    def from_dict(cls, d):
 7891        return cls(
 7892            auth_database=d.get('auth_database'),
 7893            bind_interface=d.get('bind_interface'),
 7894            egress_filter=d.get('egress_filter'),
 7895            healthy=d.get('healthy'),
 7896            hostname=d.get('hostname'),
 7897            id=d.get('id'),
 7898            name=d.get('name'),
 7899            password=d.get('password'),
 7900            port=d.get('port'),
 7901            port_override=d.get('port_override'),
 7902            replica_set=d.get('replica_set'),
 7903            secret_store_id=d.get('secret_store_id'),
 7904            tags=d.get('tags'),
 7905            tls_required=d.get('tls_required'),
 7906            username=d.get('username'),
 7907        )
 7908
 7909
 7910class MongoLegacyReplicaset:
 7911    __slots__ = [
 7912        'auth_database',
 7913        'bind_interface',
 7914        'connect_to_replica',
 7915        'egress_filter',
 7916        'healthy',
 7917        'hostname',
 7918        'id',
 7919        'name',
 7920        'password',
 7921        'port',
 7922        'port_override',
 7923        'replica_set',
 7924        'secret_store_id',
 7925        'tags',
 7926        'tls_required',
 7927        'username',
 7928    ]
 7929
 7930    def __init__(
 7931        self,
 7932        auth_database=None,
 7933        bind_interface=None,
 7934        connect_to_replica=None,
 7935        egress_filter=None,
 7936        healthy=None,
 7937        hostname=None,
 7938        id=None,
 7939        name=None,
 7940        password=None,
 7941        port=None,
 7942        port_override=None,
 7943        replica_set=None,
 7944        secret_store_id=None,
 7945        tags=None,
 7946        tls_required=None,
 7947        username=None,
 7948    ):
 7949        self.auth_database = auth_database if auth_database is not None else ''
 7950        self.bind_interface = bind_interface if bind_interface is not None else ''
 7951        '''
 7952         Bind interface
 7953        '''
 7954        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7955        self.egress_filter = egress_filter if egress_filter is not None else ''
 7956        '''
 7957         A filter applied to the routing logic to pin datasource to nodes.
 7958        '''
 7959        self.healthy = healthy if healthy is not None else False
 7960        '''
 7961         True if the datasource is reachable and the credentials are valid.
 7962        '''
 7963        self.hostname = hostname if hostname is not None else ''
 7964        self.id = id if id is not None else ''
 7965        '''
 7966         Unique identifier of the Resource.
 7967        '''
 7968        self.name = name if name is not None else ''
 7969        '''
 7970         Unique human-readable name of the Resource.
 7971        '''
 7972        self.password = password if password is not None else ''
 7973        self.port = port if port is not None else 0
 7974        self.port_override = port_override if port_override is not None else 0
 7975        self.replica_set = replica_set if replica_set is not None else ''
 7976        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7977        '''
 7978         ID of the secret store containing credentials for this resource, if any.
 7979        '''
 7980        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7981        '''
 7982         Tags is a map of key, value pairs.
 7983        '''
 7984        self.tls_required = tls_required if tls_required is not None else False
 7985        self.username = username if username is not None else ''
 7986
 7987    def __repr__(self):
 7988        return '<sdm.MongoLegacyReplicaset ' + \
 7989            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7990            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7991            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7992            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7993            'healthy: ' + repr(self.healthy) + ' ' +\
 7994            'hostname: ' + repr(self.hostname) + ' ' +\
 7995            'id: ' + repr(self.id) + ' ' +\
 7996            'name: ' + repr(self.name) + ' ' +\
 7997            'password: ' + repr(self.password) + ' ' +\
 7998            'port: ' + repr(self.port) + ' ' +\
 7999            'port_override: ' + repr(self.port_override) + ' ' +\
 8000            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8001            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8002            'tags: ' + repr(self.tags) + ' ' +\
 8003            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8004            'username: ' + repr(self.username) + ' ' +\
 8005            '>'
 8006
 8007    def to_dict(self):
 8008        return {
 8009            'auth_database': self.auth_database,
 8010            'bind_interface': self.bind_interface,
 8011            'connect_to_replica': self.connect_to_replica,
 8012            'egress_filter': self.egress_filter,
 8013            'healthy': self.healthy,
 8014            'hostname': self.hostname,
 8015            'id': self.id,
 8016            'name': self.name,
 8017            'password': self.password,
 8018            'port': self.port,
 8019            'port_override': self.port_override,
 8020            'replica_set': self.replica_set,
 8021            'secret_store_id': self.secret_store_id,
 8022            'tags': self.tags,
 8023            'tls_required': self.tls_required,
 8024            'username': self.username,
 8025        }
 8026
 8027    @classmethod
 8028    def from_dict(cls, d):
 8029        return cls(
 8030            auth_database=d.get('auth_database'),
 8031            bind_interface=d.get('bind_interface'),
 8032            connect_to_replica=d.get('connect_to_replica'),
 8033            egress_filter=d.get('egress_filter'),
 8034            healthy=d.get('healthy'),
 8035            hostname=d.get('hostname'),
 8036            id=d.get('id'),
 8037            name=d.get('name'),
 8038            password=d.get('password'),
 8039            port=d.get('port'),
 8040            port_override=d.get('port_override'),
 8041            replica_set=d.get('replica_set'),
 8042            secret_store_id=d.get('secret_store_id'),
 8043            tags=d.get('tags'),
 8044            tls_required=d.get('tls_required'),
 8045            username=d.get('username'),
 8046        )
 8047
 8048
 8049class MongoReplicaSet:
 8050    '''
 8051    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 8052    without a major version bump.
 8053    '''
 8054    __slots__ = [
 8055        'auth_database',
 8056        'bind_interface',
 8057        'connect_to_replica',
 8058        'egress_filter',
 8059        'healthy',
 8060        'hostname',
 8061        'id',
 8062        'name',
 8063        'password',
 8064        'port',
 8065        'port_override',
 8066        'replica_set',
 8067        'secret_store_id',
 8068        'tags',
 8069        'tls_required',
 8070        'username',
 8071    ]
 8072
 8073    def __init__(
 8074        self,
 8075        auth_database=None,
 8076        bind_interface=None,
 8077        connect_to_replica=None,
 8078        egress_filter=None,
 8079        healthy=None,
 8080        hostname=None,
 8081        id=None,
 8082        name=None,
 8083        password=None,
 8084        port=None,
 8085        port_override=None,
 8086        replica_set=None,
 8087        secret_store_id=None,
 8088        tags=None,
 8089        tls_required=None,
 8090        username=None,
 8091    ):
 8092        self.auth_database = auth_database if auth_database is not None else ''
 8093        self.bind_interface = bind_interface if bind_interface is not None else ''
 8094        '''
 8095         Bind interface
 8096        '''
 8097        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8098        self.egress_filter = egress_filter if egress_filter is not None else ''
 8099        '''
 8100         A filter applied to the routing logic to pin datasource to nodes.
 8101        '''
 8102        self.healthy = healthy if healthy is not None else False
 8103        '''
 8104         True if the datasource is reachable and the credentials are valid.
 8105        '''
 8106        self.hostname = hostname if hostname is not None else ''
 8107        self.id = id if id is not None else ''
 8108        '''
 8109         Unique identifier of the Resource.
 8110        '''
 8111        self.name = name if name is not None else ''
 8112        '''
 8113         Unique human-readable name of the Resource.
 8114        '''
 8115        self.password = password if password is not None else ''
 8116        self.port = port if port is not None else 0
 8117        self.port_override = port_override if port_override is not None else 0
 8118        self.replica_set = replica_set if replica_set is not None else ''
 8119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8120        '''
 8121         ID of the secret store containing credentials for this resource, if any.
 8122        '''
 8123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8124        '''
 8125         Tags is a map of key, value pairs.
 8126        '''
 8127        self.tls_required = tls_required if tls_required is not None else False
 8128        self.username = username if username is not None else ''
 8129
 8130    def __repr__(self):
 8131        return '<sdm.MongoReplicaSet ' + \
 8132            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8134            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8136            'healthy: ' + repr(self.healthy) + ' ' +\
 8137            'hostname: ' + repr(self.hostname) + ' ' +\
 8138            'id: ' + repr(self.id) + ' ' +\
 8139            'name: ' + repr(self.name) + ' ' +\
 8140            'password: ' + repr(self.password) + ' ' +\
 8141            'port: ' + repr(self.port) + ' ' +\
 8142            'port_override: ' + repr(self.port_override) + ' ' +\
 8143            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8145            'tags: ' + repr(self.tags) + ' ' +\
 8146            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8147            'username: ' + repr(self.username) + ' ' +\
 8148            '>'
 8149
 8150    def to_dict(self):
 8151        return {
 8152            'auth_database': self.auth_database,
 8153            'bind_interface': self.bind_interface,
 8154            'connect_to_replica': self.connect_to_replica,
 8155            'egress_filter': self.egress_filter,
 8156            'healthy': self.healthy,
 8157            'hostname': self.hostname,
 8158            'id': self.id,
 8159            'name': self.name,
 8160            'password': self.password,
 8161            'port': self.port,
 8162            'port_override': self.port_override,
 8163            'replica_set': self.replica_set,
 8164            'secret_store_id': self.secret_store_id,
 8165            'tags': self.tags,
 8166            'tls_required': self.tls_required,
 8167            'username': self.username,
 8168        }
 8169
 8170    @classmethod
 8171    def from_dict(cls, d):
 8172        return cls(
 8173            auth_database=d.get('auth_database'),
 8174            bind_interface=d.get('bind_interface'),
 8175            connect_to_replica=d.get('connect_to_replica'),
 8176            egress_filter=d.get('egress_filter'),
 8177            healthy=d.get('healthy'),
 8178            hostname=d.get('hostname'),
 8179            id=d.get('id'),
 8180            name=d.get('name'),
 8181            password=d.get('password'),
 8182            port=d.get('port'),
 8183            port_override=d.get('port_override'),
 8184            replica_set=d.get('replica_set'),
 8185            secret_store_id=d.get('secret_store_id'),
 8186            tags=d.get('tags'),
 8187            tls_required=d.get('tls_required'),
 8188            username=d.get('username'),
 8189        )
 8190
 8191
 8192class MongoShardedCluster:
 8193    '''
 8194    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 8195    without a major version bump.
 8196    '''
 8197    __slots__ = [
 8198        'auth_database',
 8199        'bind_interface',
 8200        'egress_filter',
 8201        'healthy',
 8202        'hostname',
 8203        'id',
 8204        'name',
 8205        'password',
 8206        'port_override',
 8207        'secret_store_id',
 8208        'tags',
 8209        'tls_required',
 8210        'username',
 8211    ]
 8212
 8213    def __init__(
 8214        self,
 8215        auth_database=None,
 8216        bind_interface=None,
 8217        egress_filter=None,
 8218        healthy=None,
 8219        hostname=None,
 8220        id=None,
 8221        name=None,
 8222        password=None,
 8223        port_override=None,
 8224        secret_store_id=None,
 8225        tags=None,
 8226        tls_required=None,
 8227        username=None,
 8228    ):
 8229        self.auth_database = auth_database if auth_database is not None else ''
 8230        self.bind_interface = bind_interface if bind_interface is not None else ''
 8231        '''
 8232         Bind interface
 8233        '''
 8234        self.egress_filter = egress_filter if egress_filter is not None else ''
 8235        '''
 8236         A filter applied to the routing logic to pin datasource to nodes.
 8237        '''
 8238        self.healthy = healthy if healthy is not None else False
 8239        '''
 8240         True if the datasource is reachable and the credentials are valid.
 8241        '''
 8242        self.hostname = hostname if hostname is not None else ''
 8243        self.id = id if id is not None else ''
 8244        '''
 8245         Unique identifier of the Resource.
 8246        '''
 8247        self.name = name if name is not None else ''
 8248        '''
 8249         Unique human-readable name of the Resource.
 8250        '''
 8251        self.password = password if password is not None else ''
 8252        self.port_override = port_override if port_override is not None else 0
 8253        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8254        '''
 8255         ID of the secret store containing credentials for this resource, if any.
 8256        '''
 8257        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8258        '''
 8259         Tags is a map of key, value pairs.
 8260        '''
 8261        self.tls_required = tls_required if tls_required is not None else False
 8262        self.username = username if username is not None else ''
 8263
 8264    def __repr__(self):
 8265        return '<sdm.MongoShardedCluster ' + \
 8266            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8267            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8268            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8269            'healthy: ' + repr(self.healthy) + ' ' +\
 8270            'hostname: ' + repr(self.hostname) + ' ' +\
 8271            'id: ' + repr(self.id) + ' ' +\
 8272            'name: ' + repr(self.name) + ' ' +\
 8273            'password: ' + repr(self.password) + ' ' +\
 8274            'port_override: ' + repr(self.port_override) + ' ' +\
 8275            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8276            'tags: ' + repr(self.tags) + ' ' +\
 8277            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8278            'username: ' + repr(self.username) + ' ' +\
 8279            '>'
 8280
 8281    def to_dict(self):
 8282        return {
 8283            'auth_database': self.auth_database,
 8284            'bind_interface': self.bind_interface,
 8285            'egress_filter': self.egress_filter,
 8286            'healthy': self.healthy,
 8287            'hostname': self.hostname,
 8288            'id': self.id,
 8289            'name': self.name,
 8290            'password': self.password,
 8291            'port_override': self.port_override,
 8292            'secret_store_id': self.secret_store_id,
 8293            'tags': self.tags,
 8294            'tls_required': self.tls_required,
 8295            'username': self.username,
 8296        }
 8297
 8298    @classmethod
 8299    def from_dict(cls, d):
 8300        return cls(
 8301            auth_database=d.get('auth_database'),
 8302            bind_interface=d.get('bind_interface'),
 8303            egress_filter=d.get('egress_filter'),
 8304            healthy=d.get('healthy'),
 8305            hostname=d.get('hostname'),
 8306            id=d.get('id'),
 8307            name=d.get('name'),
 8308            password=d.get('password'),
 8309            port_override=d.get('port_override'),
 8310            secret_store_id=d.get('secret_store_id'),
 8311            tags=d.get('tags'),
 8312            tls_required=d.get('tls_required'),
 8313            username=d.get('username'),
 8314        )
 8315
 8316
 8317class Mysql:
 8318    __slots__ = [
 8319        'bind_interface',
 8320        'database',
 8321        'egress_filter',
 8322        'healthy',
 8323        'hostname',
 8324        'id',
 8325        'name',
 8326        'password',
 8327        'port',
 8328        'port_override',
 8329        'secret_store_id',
 8330        'tags',
 8331        'username',
 8332    ]
 8333
 8334    def __init__(
 8335        self,
 8336        bind_interface=None,
 8337        database=None,
 8338        egress_filter=None,
 8339        healthy=None,
 8340        hostname=None,
 8341        id=None,
 8342        name=None,
 8343        password=None,
 8344        port=None,
 8345        port_override=None,
 8346        secret_store_id=None,
 8347        tags=None,
 8348        username=None,
 8349    ):
 8350        self.bind_interface = bind_interface if bind_interface is not None else ''
 8351        '''
 8352         Bind interface
 8353        '''
 8354        self.database = database if database is not None else ''
 8355        self.egress_filter = egress_filter if egress_filter is not None else ''
 8356        '''
 8357         A filter applied to the routing logic to pin datasource to nodes.
 8358        '''
 8359        self.healthy = healthy if healthy is not None else False
 8360        '''
 8361         True if the datasource is reachable and the credentials are valid.
 8362        '''
 8363        self.hostname = hostname if hostname is not None else ''
 8364        self.id = id if id is not None else ''
 8365        '''
 8366         Unique identifier of the Resource.
 8367        '''
 8368        self.name = name if name is not None else ''
 8369        '''
 8370         Unique human-readable name of the Resource.
 8371        '''
 8372        self.password = password if password is not None else ''
 8373        self.port = port if port is not None else 0
 8374        self.port_override = port_override if port_override is not None else 0
 8375        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8376        '''
 8377         ID of the secret store containing credentials for this resource, if any.
 8378        '''
 8379        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8380        '''
 8381         Tags is a map of key, value pairs.
 8382        '''
 8383        self.username = username if username is not None else ''
 8384
 8385    def __repr__(self):
 8386        return '<sdm.Mysql ' + \
 8387            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8388            'database: ' + repr(self.database) + ' ' +\
 8389            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8390            'healthy: ' + repr(self.healthy) + ' ' +\
 8391            'hostname: ' + repr(self.hostname) + ' ' +\
 8392            'id: ' + repr(self.id) + ' ' +\
 8393            'name: ' + repr(self.name) + ' ' +\
 8394            'password: ' + repr(self.password) + ' ' +\
 8395            'port: ' + repr(self.port) + ' ' +\
 8396            'port_override: ' + repr(self.port_override) + ' ' +\
 8397            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8398            'tags: ' + repr(self.tags) + ' ' +\
 8399            'username: ' + repr(self.username) + ' ' +\
 8400            '>'
 8401
 8402    def to_dict(self):
 8403        return {
 8404            'bind_interface': self.bind_interface,
 8405            'database': self.database,
 8406            'egress_filter': self.egress_filter,
 8407            'healthy': self.healthy,
 8408            'hostname': self.hostname,
 8409            'id': self.id,
 8410            'name': self.name,
 8411            'password': self.password,
 8412            'port': self.port,
 8413            'port_override': self.port_override,
 8414            'secret_store_id': self.secret_store_id,
 8415            'tags': self.tags,
 8416            'username': self.username,
 8417        }
 8418
 8419    @classmethod
 8420    def from_dict(cls, d):
 8421        return cls(
 8422            bind_interface=d.get('bind_interface'),
 8423            database=d.get('database'),
 8424            egress_filter=d.get('egress_filter'),
 8425            healthy=d.get('healthy'),
 8426            hostname=d.get('hostname'),
 8427            id=d.get('id'),
 8428            name=d.get('name'),
 8429            password=d.get('password'),
 8430            port=d.get('port'),
 8431            port_override=d.get('port_override'),
 8432            secret_store_id=d.get('secret_store_id'),
 8433            tags=d.get('tags'),
 8434            username=d.get('username'),
 8435        )
 8436
 8437
 8438class Neptune:
 8439    __slots__ = [
 8440        'bind_interface',
 8441        'egress_filter',
 8442        'endpoint',
 8443        'healthy',
 8444        'id',
 8445        'name',
 8446        'port',
 8447        'port_override',
 8448        'secret_store_id',
 8449        'tags',
 8450    ]
 8451
 8452    def __init__(
 8453        self,
 8454        bind_interface=None,
 8455        egress_filter=None,
 8456        endpoint=None,
 8457        healthy=None,
 8458        id=None,
 8459        name=None,
 8460        port=None,
 8461        port_override=None,
 8462        secret_store_id=None,
 8463        tags=None,
 8464    ):
 8465        self.bind_interface = bind_interface if bind_interface is not None else ''
 8466        '''
 8467         Bind interface
 8468        '''
 8469        self.egress_filter = egress_filter if egress_filter is not None else ''
 8470        '''
 8471         A filter applied to the routing logic to pin datasource to nodes.
 8472        '''
 8473        self.endpoint = endpoint if endpoint is not None else ''
 8474        self.healthy = healthy if healthy is not None else False
 8475        '''
 8476         True if the datasource is reachable and the credentials are valid.
 8477        '''
 8478        self.id = id if id is not None else ''
 8479        '''
 8480         Unique identifier of the Resource.
 8481        '''
 8482        self.name = name if name is not None else ''
 8483        '''
 8484         Unique human-readable name of the Resource.
 8485        '''
 8486        self.port = port if port is not None else 0
 8487        self.port_override = port_override if port_override is not None else 0
 8488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8489        '''
 8490         ID of the secret store containing credentials for this resource, if any.
 8491        '''
 8492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8493        '''
 8494         Tags is a map of key, value pairs.
 8495        '''
 8496
 8497    def __repr__(self):
 8498        return '<sdm.Neptune ' + \
 8499            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8500            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8501            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8502            'healthy: ' + repr(self.healthy) + ' ' +\
 8503            'id: ' + repr(self.id) + ' ' +\
 8504            'name: ' + repr(self.name) + ' ' +\
 8505            'port: ' + repr(self.port) + ' ' +\
 8506            'port_override: ' + repr(self.port_override) + ' ' +\
 8507            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8508            'tags: ' + repr(self.tags) + ' ' +\
 8509            '>'
 8510
 8511    def to_dict(self):
 8512        return {
 8513            'bind_interface': self.bind_interface,
 8514            'egress_filter': self.egress_filter,
 8515            'endpoint': self.endpoint,
 8516            'healthy': self.healthy,
 8517            'id': self.id,
 8518            'name': self.name,
 8519            'port': self.port,
 8520            'port_override': self.port_override,
 8521            'secret_store_id': self.secret_store_id,
 8522            'tags': self.tags,
 8523        }
 8524
 8525    @classmethod
 8526    def from_dict(cls, d):
 8527        return cls(
 8528            bind_interface=d.get('bind_interface'),
 8529            egress_filter=d.get('egress_filter'),
 8530            endpoint=d.get('endpoint'),
 8531            healthy=d.get('healthy'),
 8532            id=d.get('id'),
 8533            name=d.get('name'),
 8534            port=d.get('port'),
 8535            port_override=d.get('port_override'),
 8536            secret_store_id=d.get('secret_store_id'),
 8537            tags=d.get('tags'),
 8538        )
 8539
 8540
 8541class NeptuneIAM:
 8542    __slots__ = [
 8543        'access_key',
 8544        'bind_interface',
 8545        'egress_filter',
 8546        'endpoint',
 8547        'healthy',
 8548        'id',
 8549        'name',
 8550        'port',
 8551        'port_override',
 8552        'region',
 8553        'role_arn',
 8554        'role_external_id',
 8555        'secret_access_key',
 8556        'secret_store_id',
 8557        'tags',
 8558    ]
 8559
 8560    def __init__(
 8561        self,
 8562        access_key=None,
 8563        bind_interface=None,
 8564        egress_filter=None,
 8565        endpoint=None,
 8566        healthy=None,
 8567        id=None,
 8568        name=None,
 8569        port=None,
 8570        port_override=None,
 8571        region=None,
 8572        role_arn=None,
 8573        role_external_id=None,
 8574        secret_access_key=None,
 8575        secret_store_id=None,
 8576        tags=None,
 8577    ):
 8578        self.access_key = access_key if access_key is not None else ''
 8579        self.bind_interface = bind_interface if bind_interface is not None else ''
 8580        '''
 8581         Bind interface
 8582        '''
 8583        self.egress_filter = egress_filter if egress_filter is not None else ''
 8584        '''
 8585         A filter applied to the routing logic to pin datasource to nodes.
 8586        '''
 8587        self.endpoint = endpoint if endpoint is not None else ''
 8588        self.healthy = healthy if healthy is not None else False
 8589        '''
 8590         True if the datasource is reachable and the credentials are valid.
 8591        '''
 8592        self.id = id if id is not None else ''
 8593        '''
 8594         Unique identifier of the Resource.
 8595        '''
 8596        self.name = name if name is not None else ''
 8597        '''
 8598         Unique human-readable name of the Resource.
 8599        '''
 8600        self.port = port if port is not None else 0
 8601        self.port_override = port_override if port_override is not None else 0
 8602        self.region = region if region is not None else ''
 8603        self.role_arn = role_arn if role_arn is not None else ''
 8604        self.role_external_id = role_external_id if role_external_id is not None else ''
 8605        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8606        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8607        '''
 8608         ID of the secret store containing credentials for this resource, if any.
 8609        '''
 8610        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8611        '''
 8612         Tags is a map of key, value pairs.
 8613        '''
 8614
 8615    def __repr__(self):
 8616        return '<sdm.NeptuneIAM ' + \
 8617            'access_key: ' + repr(self.access_key) + ' ' +\
 8618            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8620            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8621            'healthy: ' + repr(self.healthy) + ' ' +\
 8622            'id: ' + repr(self.id) + ' ' +\
 8623            'name: ' + repr(self.name) + ' ' +\
 8624            'port: ' + repr(self.port) + ' ' +\
 8625            'port_override: ' + repr(self.port_override) + ' ' +\
 8626            'region: ' + repr(self.region) + ' ' +\
 8627            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8628            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8629            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8630            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8631            'tags: ' + repr(self.tags) + ' ' +\
 8632            '>'
 8633
 8634    def to_dict(self):
 8635        return {
 8636            'access_key': self.access_key,
 8637            'bind_interface': self.bind_interface,
 8638            'egress_filter': self.egress_filter,
 8639            'endpoint': self.endpoint,
 8640            'healthy': self.healthy,
 8641            'id': self.id,
 8642            'name': self.name,
 8643            'port': self.port,
 8644            'port_override': self.port_override,
 8645            'region': self.region,
 8646            'role_arn': self.role_arn,
 8647            'role_external_id': self.role_external_id,
 8648            'secret_access_key': self.secret_access_key,
 8649            'secret_store_id': self.secret_store_id,
 8650            'tags': self.tags,
 8651        }
 8652
 8653    @classmethod
 8654    def from_dict(cls, d):
 8655        return cls(
 8656            access_key=d.get('access_key'),
 8657            bind_interface=d.get('bind_interface'),
 8658            egress_filter=d.get('egress_filter'),
 8659            endpoint=d.get('endpoint'),
 8660            healthy=d.get('healthy'),
 8661            id=d.get('id'),
 8662            name=d.get('name'),
 8663            port=d.get('port'),
 8664            port_override=d.get('port_override'),
 8665            region=d.get('region'),
 8666            role_arn=d.get('role_arn'),
 8667            role_external_id=d.get('role_external_id'),
 8668            secret_access_key=d.get('secret_access_key'),
 8669            secret_store_id=d.get('secret_store_id'),
 8670            tags=d.get('tags'),
 8671        )
 8672
 8673
 8674class NodeCreateResponse:
 8675    '''
 8676         NodeCreateResponse reports how the Nodes were created in the system.
 8677    '''
 8678    __slots__ = [
 8679        'meta',
 8680        'node',
 8681        'rate_limit',
 8682        'token',
 8683    ]
 8684
 8685    def __init__(
 8686        self,
 8687        meta=None,
 8688        node=None,
 8689        rate_limit=None,
 8690        token=None,
 8691    ):
 8692        self.meta = meta if meta is not None else None
 8693        '''
 8694         Reserved for future use.
 8695        '''
 8696        self.node = node if node is not None else None
 8697        '''
 8698         The created Node.
 8699        '''
 8700        self.rate_limit = rate_limit if rate_limit is not None else None
 8701        '''
 8702         Rate limit information.
 8703        '''
 8704        self.token = token if token is not None else ''
 8705        '''
 8706         The auth token generated for the Node. The Node will use this token to
 8707         authenticate with the strongDM API.
 8708        '''
 8709
 8710    def __repr__(self):
 8711        return '<sdm.NodeCreateResponse ' + \
 8712            'meta: ' + repr(self.meta) + ' ' +\
 8713            'node: ' + repr(self.node) + ' ' +\
 8714            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8715            'token: ' + repr(self.token) + ' ' +\
 8716            '>'
 8717
 8718    def to_dict(self):
 8719        return {
 8720            'meta': self.meta,
 8721            'node': self.node,
 8722            'rate_limit': self.rate_limit,
 8723            'token': self.token,
 8724        }
 8725
 8726    @classmethod
 8727    def from_dict(cls, d):
 8728        return cls(
 8729            meta=d.get('meta'),
 8730            node=d.get('node'),
 8731            rate_limit=d.get('rate_limit'),
 8732            token=d.get('token'),
 8733        )
 8734
 8735
 8736class NodeDeleteResponse:
 8737    '''
 8738         NodeDeleteResponse returns information about a Node that was deleted.
 8739    '''
 8740    __slots__ = [
 8741        'meta',
 8742        'rate_limit',
 8743    ]
 8744
 8745    def __init__(
 8746        self,
 8747        meta=None,
 8748        rate_limit=None,
 8749    ):
 8750        self.meta = meta if meta is not None else None
 8751        '''
 8752         Reserved for future use.
 8753        '''
 8754        self.rate_limit = rate_limit if rate_limit is not None else None
 8755        '''
 8756         Rate limit information.
 8757        '''
 8758
 8759    def __repr__(self):
 8760        return '<sdm.NodeDeleteResponse ' + \
 8761            'meta: ' + repr(self.meta) + ' ' +\
 8762            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8763            '>'
 8764
 8765    def to_dict(self):
 8766        return {
 8767            'meta': self.meta,
 8768            'rate_limit': self.rate_limit,
 8769        }
 8770
 8771    @classmethod
 8772    def from_dict(cls, d):
 8773        return cls(
 8774            meta=d.get('meta'),
 8775            rate_limit=d.get('rate_limit'),
 8776        )
 8777
 8778
 8779class NodeGetResponse:
 8780    '''
 8781         NodeGetResponse returns a requested Node.
 8782    '''
 8783    __slots__ = [
 8784        'meta',
 8785        'node',
 8786        'rate_limit',
 8787    ]
 8788
 8789    def __init__(
 8790        self,
 8791        meta=None,
 8792        node=None,
 8793        rate_limit=None,
 8794    ):
 8795        self.meta = meta if meta is not None else None
 8796        '''
 8797         Reserved for future use.
 8798        '''
 8799        self.node = node if node is not None else None
 8800        '''
 8801         The requested Node.
 8802        '''
 8803        self.rate_limit = rate_limit if rate_limit is not None else None
 8804        '''
 8805         Rate limit information.
 8806        '''
 8807
 8808    def __repr__(self):
 8809        return '<sdm.NodeGetResponse ' + \
 8810            'meta: ' + repr(self.meta) + ' ' +\
 8811            'node: ' + repr(self.node) + ' ' +\
 8812            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8813            '>'
 8814
 8815    def to_dict(self):
 8816        return {
 8817            'meta': self.meta,
 8818            'node': self.node,
 8819            'rate_limit': self.rate_limit,
 8820        }
 8821
 8822    @classmethod
 8823    def from_dict(cls, d):
 8824        return cls(
 8825            meta=d.get('meta'),
 8826            node=d.get('node'),
 8827            rate_limit=d.get('rate_limit'),
 8828        )
 8829
 8830
 8831class NodeUpdateResponse:
 8832    '''
 8833         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8834     a NodeUpdateRequest.
 8835    '''
 8836    __slots__ = [
 8837        'meta',
 8838        'node',
 8839        'rate_limit',
 8840    ]
 8841
 8842    def __init__(
 8843        self,
 8844        meta=None,
 8845        node=None,
 8846        rate_limit=None,
 8847    ):
 8848        self.meta = meta if meta is not None else None
 8849        '''
 8850         Reserved for future use.
 8851        '''
 8852        self.node = node if node is not None else None
 8853        '''
 8854         The updated Node.
 8855        '''
 8856        self.rate_limit = rate_limit if rate_limit is not None else None
 8857        '''
 8858         Rate limit information.
 8859        '''
 8860
 8861    def __repr__(self):
 8862        return '<sdm.NodeUpdateResponse ' + \
 8863            'meta: ' + repr(self.meta) + ' ' +\
 8864            'node: ' + repr(self.node) + ' ' +\
 8865            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8866            '>'
 8867
 8868    def to_dict(self):
 8869        return {
 8870            'meta': self.meta,
 8871            'node': self.node,
 8872            'rate_limit': self.rate_limit,
 8873        }
 8874
 8875    @classmethod
 8876    def from_dict(cls, d):
 8877        return cls(
 8878            meta=d.get('meta'),
 8879            node=d.get('node'),
 8880            rate_limit=d.get('rate_limit'),
 8881        )
 8882
 8883
 8884class Oracle:
 8885    __slots__ = [
 8886        'bind_interface',
 8887        'database',
 8888        'egress_filter',
 8889        'healthy',
 8890        'hostname',
 8891        'id',
 8892        'name',
 8893        'password',
 8894        'port',
 8895        'port_override',
 8896        'secret_store_id',
 8897        'tags',
 8898        'tls_required',
 8899        'username',
 8900    ]
 8901
 8902    def __init__(
 8903        self,
 8904        bind_interface=None,
 8905        database=None,
 8906        egress_filter=None,
 8907        healthy=None,
 8908        hostname=None,
 8909        id=None,
 8910        name=None,
 8911        password=None,
 8912        port=None,
 8913        port_override=None,
 8914        secret_store_id=None,
 8915        tags=None,
 8916        tls_required=None,
 8917        username=None,
 8918    ):
 8919        self.bind_interface = bind_interface if bind_interface is not None else ''
 8920        '''
 8921         Bind interface
 8922        '''
 8923        self.database = database if database is not None else ''
 8924        self.egress_filter = egress_filter if egress_filter is not None else ''
 8925        '''
 8926         A filter applied to the routing logic to pin datasource to nodes.
 8927        '''
 8928        self.healthy = healthy if healthy is not None else False
 8929        '''
 8930         True if the datasource is reachable and the credentials are valid.
 8931        '''
 8932        self.hostname = hostname if hostname is not None else ''
 8933        self.id = id if id is not None else ''
 8934        '''
 8935         Unique identifier of the Resource.
 8936        '''
 8937        self.name = name if name is not None else ''
 8938        '''
 8939         Unique human-readable name of the Resource.
 8940        '''
 8941        self.password = password if password is not None else ''
 8942        self.port = port if port is not None else 0
 8943        self.port_override = port_override if port_override is not None else 0
 8944        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8945        '''
 8946         ID of the secret store containing credentials for this resource, if any.
 8947        '''
 8948        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8949        '''
 8950         Tags is a map of key, value pairs.
 8951        '''
 8952        self.tls_required = tls_required if tls_required is not None else False
 8953        self.username = username if username is not None else ''
 8954
 8955    def __repr__(self):
 8956        return '<sdm.Oracle ' + \
 8957            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8958            'database: ' + repr(self.database) + ' ' +\
 8959            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8960            'healthy: ' + repr(self.healthy) + ' ' +\
 8961            'hostname: ' + repr(self.hostname) + ' ' +\
 8962            'id: ' + repr(self.id) + ' ' +\
 8963            'name: ' + repr(self.name) + ' ' +\
 8964            'password: ' + repr(self.password) + ' ' +\
 8965            'port: ' + repr(self.port) + ' ' +\
 8966            'port_override: ' + repr(self.port_override) + ' ' +\
 8967            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8968            'tags: ' + repr(self.tags) + ' ' +\
 8969            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8970            'username: ' + repr(self.username) + ' ' +\
 8971            '>'
 8972
 8973    def to_dict(self):
 8974        return {
 8975            'bind_interface': self.bind_interface,
 8976            'database': self.database,
 8977            'egress_filter': self.egress_filter,
 8978            'healthy': self.healthy,
 8979            'hostname': self.hostname,
 8980            'id': self.id,
 8981            'name': self.name,
 8982            'password': self.password,
 8983            'port': self.port,
 8984            'port_override': self.port_override,
 8985            'secret_store_id': self.secret_store_id,
 8986            'tags': self.tags,
 8987            'tls_required': self.tls_required,
 8988            'username': self.username,
 8989        }
 8990
 8991    @classmethod
 8992    def from_dict(cls, d):
 8993        return cls(
 8994            bind_interface=d.get('bind_interface'),
 8995            database=d.get('database'),
 8996            egress_filter=d.get('egress_filter'),
 8997            healthy=d.get('healthy'),
 8998            hostname=d.get('hostname'),
 8999            id=d.get('id'),
 9000            name=d.get('name'),
 9001            password=d.get('password'),
 9002            port=d.get('port'),
 9003            port_override=d.get('port_override'),
 9004            secret_store_id=d.get('secret_store_id'),
 9005            tags=d.get('tags'),
 9006            tls_required=d.get('tls_required'),
 9007            username=d.get('username'),
 9008        )
 9009
 9010
 9011class Postgres:
 9012    __slots__ = [
 9013        'bind_interface',
 9014        'database',
 9015        'egress_filter',
 9016        'healthy',
 9017        'hostname',
 9018        'id',
 9019        'name',
 9020        'override_database',
 9021        'password',
 9022        'port',
 9023        'port_override',
 9024        'secret_store_id',
 9025        'tags',
 9026        'username',
 9027    ]
 9028
 9029    def __init__(
 9030        self,
 9031        bind_interface=None,
 9032        database=None,
 9033        egress_filter=None,
 9034        healthy=None,
 9035        hostname=None,
 9036        id=None,
 9037        name=None,
 9038        override_database=None,
 9039        password=None,
 9040        port=None,
 9041        port_override=None,
 9042        secret_store_id=None,
 9043        tags=None,
 9044        username=None,
 9045    ):
 9046        self.bind_interface = bind_interface if bind_interface is not None else ''
 9047        '''
 9048         Bind interface
 9049        '''
 9050        self.database = database if database is not None else ''
 9051        self.egress_filter = egress_filter if egress_filter is not None else ''
 9052        '''
 9053         A filter applied to the routing logic to pin datasource to nodes.
 9054        '''
 9055        self.healthy = healthy if healthy is not None else False
 9056        '''
 9057         True if the datasource is reachable and the credentials are valid.
 9058        '''
 9059        self.hostname = hostname if hostname is not None else ''
 9060        self.id = id if id is not None else ''
 9061        '''
 9062         Unique identifier of the Resource.
 9063        '''
 9064        self.name = name if name is not None else ''
 9065        '''
 9066         Unique human-readable name of the Resource.
 9067        '''
 9068        self.override_database = override_database if override_database is not None else False
 9069        self.password = password if password is not None else ''
 9070        self.port = port if port is not None else 0
 9071        self.port_override = port_override if port_override is not None else 0
 9072        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9073        '''
 9074         ID of the secret store containing credentials for this resource, if any.
 9075        '''
 9076        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9077        '''
 9078         Tags is a map of key, value pairs.
 9079        '''
 9080        self.username = username if username is not None else ''
 9081
 9082    def __repr__(self):
 9083        return '<sdm.Postgres ' + \
 9084            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9085            'database: ' + repr(self.database) + ' ' +\
 9086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9087            'healthy: ' + repr(self.healthy) + ' ' +\
 9088            'hostname: ' + repr(self.hostname) + ' ' +\
 9089            'id: ' + repr(self.id) + ' ' +\
 9090            'name: ' + repr(self.name) + ' ' +\
 9091            'override_database: ' + repr(self.override_database) + ' ' +\
 9092            'password: ' + repr(self.password) + ' ' +\
 9093            'port: ' + repr(self.port) + ' ' +\
 9094            'port_override: ' + repr(self.port_override) + ' ' +\
 9095            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9096            'tags: ' + repr(self.tags) + ' ' +\
 9097            'username: ' + repr(self.username) + ' ' +\
 9098            '>'
 9099
 9100    def to_dict(self):
 9101        return {
 9102            'bind_interface': self.bind_interface,
 9103            'database': self.database,
 9104            'egress_filter': self.egress_filter,
 9105            'healthy': self.healthy,
 9106            'hostname': self.hostname,
 9107            'id': self.id,
 9108            'name': self.name,
 9109            'override_database': self.override_database,
 9110            'password': self.password,
 9111            'port': self.port,
 9112            'port_override': self.port_override,
 9113            'secret_store_id': self.secret_store_id,
 9114            'tags': self.tags,
 9115            'username': self.username,
 9116        }
 9117
 9118    @classmethod
 9119    def from_dict(cls, d):
 9120        return cls(
 9121            bind_interface=d.get('bind_interface'),
 9122            database=d.get('database'),
 9123            egress_filter=d.get('egress_filter'),
 9124            healthy=d.get('healthy'),
 9125            hostname=d.get('hostname'),
 9126            id=d.get('id'),
 9127            name=d.get('name'),
 9128            override_database=d.get('override_database'),
 9129            password=d.get('password'),
 9130            port=d.get('port'),
 9131            port_override=d.get('port_override'),
 9132            secret_store_id=d.get('secret_store_id'),
 9133            tags=d.get('tags'),
 9134            username=d.get('username'),
 9135        )
 9136
 9137
 9138class Presto:
 9139    __slots__ = [
 9140        'bind_interface',
 9141        'database',
 9142        'egress_filter',
 9143        'healthy',
 9144        'hostname',
 9145        'id',
 9146        'name',
 9147        'password',
 9148        'port',
 9149        'port_override',
 9150        'secret_store_id',
 9151        'tags',
 9152        'tls_required',
 9153        'username',
 9154    ]
 9155
 9156    def __init__(
 9157        self,
 9158        bind_interface=None,
 9159        database=None,
 9160        egress_filter=None,
 9161        healthy=None,
 9162        hostname=None,
 9163        id=None,
 9164        name=None,
 9165        password=None,
 9166        port=None,
 9167        port_override=None,
 9168        secret_store_id=None,
 9169        tags=None,
 9170        tls_required=None,
 9171        username=None,
 9172    ):
 9173        self.bind_interface = bind_interface if bind_interface is not None else ''
 9174        '''
 9175         Bind interface
 9176        '''
 9177        self.database = database if database is not None else ''
 9178        self.egress_filter = egress_filter if egress_filter is not None else ''
 9179        '''
 9180         A filter applied to the routing logic to pin datasource to nodes.
 9181        '''
 9182        self.healthy = healthy if healthy is not None else False
 9183        '''
 9184         True if the datasource is reachable and the credentials are valid.
 9185        '''
 9186        self.hostname = hostname if hostname is not None else ''
 9187        self.id = id if id is not None else ''
 9188        '''
 9189         Unique identifier of the Resource.
 9190        '''
 9191        self.name = name if name is not None else ''
 9192        '''
 9193         Unique human-readable name of the Resource.
 9194        '''
 9195        self.password = password if password is not None else ''
 9196        self.port = port if port is not None else 0
 9197        self.port_override = port_override if port_override is not None else 0
 9198        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9199        '''
 9200         ID of the secret store containing credentials for this resource, if any.
 9201        '''
 9202        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9203        '''
 9204         Tags is a map of key, value pairs.
 9205        '''
 9206        self.tls_required = tls_required if tls_required is not None else False
 9207        self.username = username if username is not None else ''
 9208
 9209    def __repr__(self):
 9210        return '<sdm.Presto ' + \
 9211            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9212            'database: ' + repr(self.database) + ' ' +\
 9213            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9214            'healthy: ' + repr(self.healthy) + ' ' +\
 9215            'hostname: ' + repr(self.hostname) + ' ' +\
 9216            'id: ' + repr(self.id) + ' ' +\
 9217            'name: ' + repr(self.name) + ' ' +\
 9218            'password: ' + repr(self.password) + ' ' +\
 9219            'port: ' + repr(self.port) + ' ' +\
 9220            'port_override: ' + repr(self.port_override) + ' ' +\
 9221            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9222            'tags: ' + repr(self.tags) + ' ' +\
 9223            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9224            'username: ' + repr(self.username) + ' ' +\
 9225            '>'
 9226
 9227    def to_dict(self):
 9228        return {
 9229            'bind_interface': self.bind_interface,
 9230            'database': self.database,
 9231            'egress_filter': self.egress_filter,
 9232            'healthy': self.healthy,
 9233            'hostname': self.hostname,
 9234            'id': self.id,
 9235            'name': self.name,
 9236            'password': self.password,
 9237            'port': self.port,
 9238            'port_override': self.port_override,
 9239            'secret_store_id': self.secret_store_id,
 9240            'tags': self.tags,
 9241            'tls_required': self.tls_required,
 9242            'username': self.username,
 9243        }
 9244
 9245    @classmethod
 9246    def from_dict(cls, d):
 9247        return cls(
 9248            bind_interface=d.get('bind_interface'),
 9249            database=d.get('database'),
 9250            egress_filter=d.get('egress_filter'),
 9251            healthy=d.get('healthy'),
 9252            hostname=d.get('hostname'),
 9253            id=d.get('id'),
 9254            name=d.get('name'),
 9255            password=d.get('password'),
 9256            port=d.get('port'),
 9257            port_override=d.get('port_override'),
 9258            secret_store_id=d.get('secret_store_id'),
 9259            tags=d.get('tags'),
 9260            tls_required=d.get('tls_required'),
 9261            username=d.get('username'),
 9262        )
 9263
 9264
 9265class RDP:
 9266    __slots__ = [
 9267        'bind_interface',
 9268        'downgrade_nla_connections',
 9269        'egress_filter',
 9270        'healthy',
 9271        'hostname',
 9272        'id',
 9273        'name',
 9274        'password',
 9275        'port',
 9276        'port_override',
 9277        'secret_store_id',
 9278        'tags',
 9279        'username',
 9280    ]
 9281
 9282    def __init__(
 9283        self,
 9284        bind_interface=None,
 9285        downgrade_nla_connections=None,
 9286        egress_filter=None,
 9287        healthy=None,
 9288        hostname=None,
 9289        id=None,
 9290        name=None,
 9291        password=None,
 9292        port=None,
 9293        port_override=None,
 9294        secret_store_id=None,
 9295        tags=None,
 9296        username=None,
 9297    ):
 9298        self.bind_interface = bind_interface if bind_interface is not None else ''
 9299        '''
 9300         Bind interface
 9301        '''
 9302        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9303        self.egress_filter = egress_filter if egress_filter is not None else ''
 9304        '''
 9305         A filter applied to the routing logic to pin datasource to nodes.
 9306        '''
 9307        self.healthy = healthy if healthy is not None else False
 9308        '''
 9309         True if the datasource is reachable and the credentials are valid.
 9310        '''
 9311        self.hostname = hostname if hostname is not None else ''
 9312        self.id = id if id is not None else ''
 9313        '''
 9314         Unique identifier of the Resource.
 9315        '''
 9316        self.name = name if name is not None else ''
 9317        '''
 9318         Unique human-readable name of the Resource.
 9319        '''
 9320        self.password = password if password is not None else ''
 9321        self.port = port if port is not None else 0
 9322        self.port_override = port_override if port_override is not None else 0
 9323        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9324        '''
 9325         ID of the secret store containing credentials for this resource, if any.
 9326        '''
 9327        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9328        '''
 9329         Tags is a map of key, value pairs.
 9330        '''
 9331        self.username = username if username is not None else ''
 9332
 9333    def __repr__(self):
 9334        return '<sdm.RDP ' + \
 9335            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9336            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9337            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9338            'healthy: ' + repr(self.healthy) + ' ' +\
 9339            'hostname: ' + repr(self.hostname) + ' ' +\
 9340            'id: ' + repr(self.id) + ' ' +\
 9341            'name: ' + repr(self.name) + ' ' +\
 9342            'password: ' + repr(self.password) + ' ' +\
 9343            'port: ' + repr(self.port) + ' ' +\
 9344            'port_override: ' + repr(self.port_override) + ' ' +\
 9345            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9346            'tags: ' + repr(self.tags) + ' ' +\
 9347            'username: ' + repr(self.username) + ' ' +\
 9348            '>'
 9349
 9350    def to_dict(self):
 9351        return {
 9352            'bind_interface': self.bind_interface,
 9353            'downgrade_nla_connections': self.downgrade_nla_connections,
 9354            'egress_filter': self.egress_filter,
 9355            'healthy': self.healthy,
 9356            'hostname': self.hostname,
 9357            'id': self.id,
 9358            'name': self.name,
 9359            'password': self.password,
 9360            'port': self.port,
 9361            'port_override': self.port_override,
 9362            'secret_store_id': self.secret_store_id,
 9363            'tags': self.tags,
 9364            'username': self.username,
 9365        }
 9366
 9367    @classmethod
 9368    def from_dict(cls, d):
 9369        return cls(
 9370            bind_interface=d.get('bind_interface'),
 9371            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9372            egress_filter=d.get('egress_filter'),
 9373            healthy=d.get('healthy'),
 9374            hostname=d.get('hostname'),
 9375            id=d.get('id'),
 9376            name=d.get('name'),
 9377            password=d.get('password'),
 9378            port=d.get('port'),
 9379            port_override=d.get('port_override'),
 9380            secret_store_id=d.get('secret_store_id'),
 9381            tags=d.get('tags'),
 9382            username=d.get('username'),
 9383        )
 9384
 9385
 9386class RabbitMQAMQP091:
 9387    __slots__ = [
 9388        'bind_interface',
 9389        'egress_filter',
 9390        'healthy',
 9391        'hostname',
 9392        'id',
 9393        'name',
 9394        'password',
 9395        'port',
 9396        'port_override',
 9397        'secret_store_id',
 9398        'tags',
 9399        'tls_required',
 9400        'username',
 9401    ]
 9402
 9403    def __init__(
 9404        self,
 9405        bind_interface=None,
 9406        egress_filter=None,
 9407        healthy=None,
 9408        hostname=None,
 9409        id=None,
 9410        name=None,
 9411        password=None,
 9412        port=None,
 9413        port_override=None,
 9414        secret_store_id=None,
 9415        tags=None,
 9416        tls_required=None,
 9417        username=None,
 9418    ):
 9419        self.bind_interface = bind_interface if bind_interface is not None else ''
 9420        '''
 9421         Bind interface
 9422        '''
 9423        self.egress_filter = egress_filter if egress_filter is not None else ''
 9424        '''
 9425         A filter applied to the routing logic to pin datasource to nodes.
 9426        '''
 9427        self.healthy = healthy if healthy is not None else False
 9428        '''
 9429         True if the datasource is reachable and the credentials are valid.
 9430        '''
 9431        self.hostname = hostname if hostname is not None else ''
 9432        self.id = id if id is not None else ''
 9433        '''
 9434         Unique identifier of the Resource.
 9435        '''
 9436        self.name = name if name is not None else ''
 9437        '''
 9438         Unique human-readable name of the Resource.
 9439        '''
 9440        self.password = password if password is not None else ''
 9441        self.port = port if port is not None else 0
 9442        self.port_override = port_override if port_override is not None else 0
 9443        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9444        '''
 9445         ID of the secret store containing credentials for this resource, if any.
 9446        '''
 9447        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9448        '''
 9449         Tags is a map of key, value pairs.
 9450        '''
 9451        self.tls_required = tls_required if tls_required is not None else False
 9452        self.username = username if username is not None else ''
 9453
 9454    def __repr__(self):
 9455        return '<sdm.RabbitMQAMQP091 ' + \
 9456            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9457            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9458            'healthy: ' + repr(self.healthy) + ' ' +\
 9459            'hostname: ' + repr(self.hostname) + ' ' +\
 9460            'id: ' + repr(self.id) + ' ' +\
 9461            'name: ' + repr(self.name) + ' ' +\
 9462            'password: ' + repr(self.password) + ' ' +\
 9463            'port: ' + repr(self.port) + ' ' +\
 9464            'port_override: ' + repr(self.port_override) + ' ' +\
 9465            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9466            'tags: ' + repr(self.tags) + ' ' +\
 9467            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9468            'username: ' + repr(self.username) + ' ' +\
 9469            '>'
 9470
 9471    def to_dict(self):
 9472        return {
 9473            'bind_interface': self.bind_interface,
 9474            'egress_filter': self.egress_filter,
 9475            'healthy': self.healthy,
 9476            'hostname': self.hostname,
 9477            'id': self.id,
 9478            'name': self.name,
 9479            'password': self.password,
 9480            'port': self.port,
 9481            'port_override': self.port_override,
 9482            'secret_store_id': self.secret_store_id,
 9483            'tags': self.tags,
 9484            'tls_required': self.tls_required,
 9485            'username': self.username,
 9486        }
 9487
 9488    @classmethod
 9489    def from_dict(cls, d):
 9490        return cls(
 9491            bind_interface=d.get('bind_interface'),
 9492            egress_filter=d.get('egress_filter'),
 9493            healthy=d.get('healthy'),
 9494            hostname=d.get('hostname'),
 9495            id=d.get('id'),
 9496            name=d.get('name'),
 9497            password=d.get('password'),
 9498            port=d.get('port'),
 9499            port_override=d.get('port_override'),
 9500            secret_store_id=d.get('secret_store_id'),
 9501            tags=d.get('tags'),
 9502            tls_required=d.get('tls_required'),
 9503            username=d.get('username'),
 9504        )
 9505
 9506
 9507class RateLimitMetadata:
 9508    '''
 9509         RateLimitMetadata contains information about remaining requests avaialable
 9510     to the user over some timeframe.
 9511    '''
 9512    __slots__ = [
 9513        'bucket',
 9514        'limit',
 9515        'remaining',
 9516        'reset_at',
 9517    ]
 9518
 9519    def __init__(
 9520        self,
 9521        bucket=None,
 9522        limit=None,
 9523        remaining=None,
 9524        reset_at=None,
 9525    ):
 9526        self.bucket = bucket if bucket is not None else ''
 9527        '''
 9528         The bucket this user/token is associated with, which may be shared between
 9529         multiple users/tokens.
 9530        '''
 9531        self.limit = limit if limit is not None else 0
 9532        '''
 9533         How many total requests the user/token is authorized to make before being
 9534         rate limited.
 9535        '''
 9536        self.remaining = remaining if remaining is not None else 0
 9537        '''
 9538         How many remaining requests out of the limit are still avaialable.
 9539        '''
 9540        self.reset_at = reset_at if reset_at is not None else None
 9541        '''
 9542         The time when remaining will be reset to limit.
 9543        '''
 9544
 9545    def __repr__(self):
 9546        return '<sdm.RateLimitMetadata ' + \
 9547            'bucket: ' + repr(self.bucket) + ' ' +\
 9548            'limit: ' + repr(self.limit) + ' ' +\
 9549            'remaining: ' + repr(self.remaining) + ' ' +\
 9550            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9551            '>'
 9552
 9553    def to_dict(self):
 9554        return {
 9555            'bucket': self.bucket,
 9556            'limit': self.limit,
 9557            'remaining': self.remaining,
 9558            'reset_at': self.reset_at,
 9559        }
 9560
 9561    @classmethod
 9562    def from_dict(cls, d):
 9563        return cls(
 9564            bucket=d.get('bucket'),
 9565            limit=d.get('limit'),
 9566            remaining=d.get('remaining'),
 9567            reset_at=d.get('reset_at'),
 9568        )
 9569
 9570
 9571class RawTCP:
 9572    __slots__ = [
 9573        'bind_interface',
 9574        'egress_filter',
 9575        'healthy',
 9576        'hostname',
 9577        'id',
 9578        'name',
 9579        'port',
 9580        'port_override',
 9581        'secret_store_id',
 9582        'tags',
 9583    ]
 9584
 9585    def __init__(
 9586        self,
 9587        bind_interface=None,
 9588        egress_filter=None,
 9589        healthy=None,
 9590        hostname=None,
 9591        id=None,
 9592        name=None,
 9593        port=None,
 9594        port_override=None,
 9595        secret_store_id=None,
 9596        tags=None,
 9597    ):
 9598        self.bind_interface = bind_interface if bind_interface is not None else ''
 9599        '''
 9600         Bind interface
 9601        '''
 9602        self.egress_filter = egress_filter if egress_filter is not None else ''
 9603        '''
 9604         A filter applied to the routing logic to pin datasource to nodes.
 9605        '''
 9606        self.healthy = healthy if healthy is not None else False
 9607        '''
 9608         True if the datasource is reachable and the credentials are valid.
 9609        '''
 9610        self.hostname = hostname if hostname is not None else ''
 9611        self.id = id if id is not None else ''
 9612        '''
 9613         Unique identifier of the Resource.
 9614        '''
 9615        self.name = name if name is not None else ''
 9616        '''
 9617         Unique human-readable name of the Resource.
 9618        '''
 9619        self.port = port if port is not None else 0
 9620        self.port_override = port_override if port_override is not None else 0
 9621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9622        '''
 9623         ID of the secret store containing credentials for this resource, if any.
 9624        '''
 9625        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9626        '''
 9627         Tags is a map of key, value pairs.
 9628        '''
 9629
 9630    def __repr__(self):
 9631        return '<sdm.RawTCP ' + \
 9632            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9633            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9634            'healthy: ' + repr(self.healthy) + ' ' +\
 9635            'hostname: ' + repr(self.hostname) + ' ' +\
 9636            'id: ' + repr(self.id) + ' ' +\
 9637            'name: ' + repr(self.name) + ' ' +\
 9638            'port: ' + repr(self.port) + ' ' +\
 9639            'port_override: ' + repr(self.port_override) + ' ' +\
 9640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9641            'tags: ' + repr(self.tags) + ' ' +\
 9642            '>'
 9643
 9644    def to_dict(self):
 9645        return {
 9646            'bind_interface': self.bind_interface,
 9647            'egress_filter': self.egress_filter,
 9648            'healthy': self.healthy,
 9649            'hostname': self.hostname,
 9650            'id': self.id,
 9651            'name': self.name,
 9652            'port': self.port,
 9653            'port_override': self.port_override,
 9654            'secret_store_id': self.secret_store_id,
 9655            'tags': self.tags,
 9656        }
 9657
 9658    @classmethod
 9659    def from_dict(cls, d):
 9660        return cls(
 9661            bind_interface=d.get('bind_interface'),
 9662            egress_filter=d.get('egress_filter'),
 9663            healthy=d.get('healthy'),
 9664            hostname=d.get('hostname'),
 9665            id=d.get('id'),
 9666            name=d.get('name'),
 9667            port=d.get('port'),
 9668            port_override=d.get('port_override'),
 9669            secret_store_id=d.get('secret_store_id'),
 9670            tags=d.get('tags'),
 9671        )
 9672
 9673
 9674class Redis:
 9675    __slots__ = [
 9676        'bind_interface',
 9677        'egress_filter',
 9678        'healthy',
 9679        'hostname',
 9680        'id',
 9681        'name',
 9682        'password',
 9683        'port',
 9684        'port_override',
 9685        'secret_store_id',
 9686        'tags',
 9687        'tls_required',
 9688        'username',
 9689    ]
 9690
 9691    def __init__(
 9692        self,
 9693        bind_interface=None,
 9694        egress_filter=None,
 9695        healthy=None,
 9696        hostname=None,
 9697        id=None,
 9698        name=None,
 9699        password=None,
 9700        port=None,
 9701        port_override=None,
 9702        secret_store_id=None,
 9703        tags=None,
 9704        tls_required=None,
 9705        username=None,
 9706    ):
 9707        self.bind_interface = bind_interface if bind_interface is not None else ''
 9708        '''
 9709         Bind interface
 9710        '''
 9711        self.egress_filter = egress_filter if egress_filter is not None else ''
 9712        '''
 9713         A filter applied to the routing logic to pin datasource to nodes.
 9714        '''
 9715        self.healthy = healthy if healthy is not None else False
 9716        '''
 9717         True if the datasource is reachable and the credentials are valid.
 9718        '''
 9719        self.hostname = hostname if hostname is not None else ''
 9720        self.id = id if id is not None else ''
 9721        '''
 9722         Unique identifier of the Resource.
 9723        '''
 9724        self.name = name if name is not None else ''
 9725        '''
 9726         Unique human-readable name of the Resource.
 9727        '''
 9728        self.password = password if password is not None else ''
 9729        self.port = port if port is not None else 0
 9730        self.port_override = port_override if port_override is not None else 0
 9731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9732        '''
 9733         ID of the secret store containing credentials for this resource, if any.
 9734        '''
 9735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9736        '''
 9737         Tags is a map of key, value pairs.
 9738        '''
 9739        self.tls_required = tls_required if tls_required is not None else False
 9740        self.username = username if username is not None else ''
 9741
 9742    def __repr__(self):
 9743        return '<sdm.Redis ' + \
 9744            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9745            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9746            'healthy: ' + repr(self.healthy) + ' ' +\
 9747            'hostname: ' + repr(self.hostname) + ' ' +\
 9748            'id: ' + repr(self.id) + ' ' +\
 9749            'name: ' + repr(self.name) + ' ' +\
 9750            'password: ' + repr(self.password) + ' ' +\
 9751            'port: ' + repr(self.port) + ' ' +\
 9752            'port_override: ' + repr(self.port_override) + ' ' +\
 9753            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9754            'tags: ' + repr(self.tags) + ' ' +\
 9755            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9756            'username: ' + repr(self.username) + ' ' +\
 9757            '>'
 9758
 9759    def to_dict(self):
 9760        return {
 9761            'bind_interface': self.bind_interface,
 9762            'egress_filter': self.egress_filter,
 9763            'healthy': self.healthy,
 9764            'hostname': self.hostname,
 9765            'id': self.id,
 9766            'name': self.name,
 9767            'password': self.password,
 9768            'port': self.port,
 9769            'port_override': self.port_override,
 9770            'secret_store_id': self.secret_store_id,
 9771            'tags': self.tags,
 9772            'tls_required': self.tls_required,
 9773            'username': self.username,
 9774        }
 9775
 9776    @classmethod
 9777    def from_dict(cls, d):
 9778        return cls(
 9779            bind_interface=d.get('bind_interface'),
 9780            egress_filter=d.get('egress_filter'),
 9781            healthy=d.get('healthy'),
 9782            hostname=d.get('hostname'),
 9783            id=d.get('id'),
 9784            name=d.get('name'),
 9785            password=d.get('password'),
 9786            port=d.get('port'),
 9787            port_override=d.get('port_override'),
 9788            secret_store_id=d.get('secret_store_id'),
 9789            tags=d.get('tags'),
 9790            tls_required=d.get('tls_required'),
 9791            username=d.get('username'),
 9792        )
 9793
 9794
 9795class Redshift:
 9796    __slots__ = [
 9797        'bind_interface',
 9798        'database',
 9799        'egress_filter',
 9800        'healthy',
 9801        'hostname',
 9802        'id',
 9803        'name',
 9804        'override_database',
 9805        'password',
 9806        'port',
 9807        'port_override',
 9808        'secret_store_id',
 9809        'tags',
 9810        'username',
 9811    ]
 9812
 9813    def __init__(
 9814        self,
 9815        bind_interface=None,
 9816        database=None,
 9817        egress_filter=None,
 9818        healthy=None,
 9819        hostname=None,
 9820        id=None,
 9821        name=None,
 9822        override_database=None,
 9823        password=None,
 9824        port=None,
 9825        port_override=None,
 9826        secret_store_id=None,
 9827        tags=None,
 9828        username=None,
 9829    ):
 9830        self.bind_interface = bind_interface if bind_interface is not None else ''
 9831        '''
 9832         Bind interface
 9833        '''
 9834        self.database = database if database is not None else ''
 9835        self.egress_filter = egress_filter if egress_filter is not None else ''
 9836        '''
 9837         A filter applied to the routing logic to pin datasource to nodes.
 9838        '''
 9839        self.healthy = healthy if healthy is not None else False
 9840        '''
 9841         True if the datasource is reachable and the credentials are valid.
 9842        '''
 9843        self.hostname = hostname if hostname is not None else ''
 9844        self.id = id if id is not None else ''
 9845        '''
 9846         Unique identifier of the Resource.
 9847        '''
 9848        self.name = name if name is not None else ''
 9849        '''
 9850         Unique human-readable name of the Resource.
 9851        '''
 9852        self.override_database = override_database if override_database is not None else False
 9853        self.password = password if password is not None else ''
 9854        self.port = port if port is not None else 0
 9855        self.port_override = port_override if port_override is not None else 0
 9856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9857        '''
 9858         ID of the secret store containing credentials for this resource, if any.
 9859        '''
 9860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9861        '''
 9862         Tags is a map of key, value pairs.
 9863        '''
 9864        self.username = username if username is not None else ''
 9865
 9866    def __repr__(self):
 9867        return '<sdm.Redshift ' + \
 9868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9869            'database: ' + repr(self.database) + ' ' +\
 9870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9871            'healthy: ' + repr(self.healthy) + ' ' +\
 9872            'hostname: ' + repr(self.hostname) + ' ' +\
 9873            'id: ' + repr(self.id) + ' ' +\
 9874            'name: ' + repr(self.name) + ' ' +\
 9875            'override_database: ' + repr(self.override_database) + ' ' +\
 9876            'password: ' + repr(self.password) + ' ' +\
 9877            'port: ' + repr(self.port) + ' ' +\
 9878            'port_override: ' + repr(self.port_override) + ' ' +\
 9879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9880            'tags: ' + repr(self.tags) + ' ' +\
 9881            'username: ' + repr(self.username) + ' ' +\
 9882            '>'
 9883
 9884    def to_dict(self):
 9885        return {
 9886            'bind_interface': self.bind_interface,
 9887            'database': self.database,
 9888            'egress_filter': self.egress_filter,
 9889            'healthy': self.healthy,
 9890            'hostname': self.hostname,
 9891            'id': self.id,
 9892            'name': self.name,
 9893            'override_database': self.override_database,
 9894            'password': self.password,
 9895            'port': self.port,
 9896            'port_override': self.port_override,
 9897            'secret_store_id': self.secret_store_id,
 9898            'tags': self.tags,
 9899            'username': self.username,
 9900        }
 9901
 9902    @classmethod
 9903    def from_dict(cls, d):
 9904        return cls(
 9905            bind_interface=d.get('bind_interface'),
 9906            database=d.get('database'),
 9907            egress_filter=d.get('egress_filter'),
 9908            healthy=d.get('healthy'),
 9909            hostname=d.get('hostname'),
 9910            id=d.get('id'),
 9911            name=d.get('name'),
 9912            override_database=d.get('override_database'),
 9913            password=d.get('password'),
 9914            port=d.get('port'),
 9915            port_override=d.get('port_override'),
 9916            secret_store_id=d.get('secret_store_id'),
 9917            tags=d.get('tags'),
 9918            username=d.get('username'),
 9919        )
 9920
 9921
 9922class Relay:
 9923    '''
 9924         Relay represents a StrongDM CLI installation running in relay mode.
 9925    '''
 9926    __slots__ = [
 9927        'device',
 9928        'gateway_filter',
 9929        'id',
 9930        'location',
 9931        'name',
 9932        'state',
 9933        'tags',
 9934        'version',
 9935    ]
 9936
 9937    def __init__(
 9938        self,
 9939        device=None,
 9940        gateway_filter=None,
 9941        id=None,
 9942        location=None,
 9943        name=None,
 9944        state=None,
 9945        tags=None,
 9946        version=None,
 9947    ):
 9948        self.device = device if device is not None else ''
 9949        '''
 9950         Device is a read only device name uploaded by the gateway process when 
 9951         it comes online.
 9952        '''
 9953        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9954        '''
 9955         GatewayFilter can be used to restrict the peering between relays and
 9956         gateways.
 9957        '''
 9958        self.id = id if id is not None else ''
 9959        '''
 9960         Unique identifier of the Relay.
 9961        '''
 9962        self.location = location if location is not None else ''
 9963        '''
 9964         Location is a read only network location uploaded by the gateway process
 9965         when it comes online.
 9966        '''
 9967        self.name = name if name is not None else ''
 9968        '''
 9969         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9970        '''
 9971        self.state = state if state is not None else ''
 9972        '''
 9973         The current state of the relay. One of: "new", "verifying_restart",
 9974         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9975         "unknown".
 9976        '''
 9977        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9978        '''
 9979         Tags is a map of key, value pairs.
 9980        '''
 9981        self.version = version if version is not None else ''
 9982        '''
 9983         Version is a read only sdm binary version uploaded by the gateway process
 9984         when it comes online.
 9985        '''
 9986
 9987    def __repr__(self):
 9988        return '<sdm.Relay ' + \
 9989            'device: ' + repr(self.device) + ' ' +\
 9990            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9991            'id: ' + repr(self.id) + ' ' +\
 9992            'location: ' + repr(self.location) + ' ' +\
 9993            'name: ' + repr(self.name) + ' ' +\
 9994            'state: ' + repr(self.state) + ' ' +\
 9995            'tags: ' + repr(self.tags) + ' ' +\
 9996            'version: ' + repr(self.version) + ' ' +\
 9997            '>'
 9998
 9999    def to_dict(self):
10000        return {
10001            'device': self.device,
10002            'gateway_filter': self.gateway_filter,
10003            'id': self.id,
10004            'location': self.location,
10005            'name': self.name,
10006            'state': self.state,
10007            'tags': self.tags,
10008            'version': self.version,
10009        }
10010
10011    @classmethod
10012    def from_dict(cls, d):
10013        return cls(
10014            device=d.get('device'),
10015            gateway_filter=d.get('gateway_filter'),
10016            id=d.get('id'),
10017            location=d.get('location'),
10018            name=d.get('name'),
10019            state=d.get('state'),
10020            tags=d.get('tags'),
10021            version=d.get('version'),
10022        )
10023
10024
10025class RemoteIdentity:
10026    '''
10027         RemoteIdentities define the username to be used for a specific account
10028     when connecting to a remote resource using that group.
10029    '''
10030    __slots__ = [
10031        'account_id',
10032        'id',
10033        'remote_identity_group_id',
10034        'username',
10035    ]
10036
10037    def __init__(
10038        self,
10039        account_id=None,
10040        id=None,
10041        remote_identity_group_id=None,
10042        username=None,
10043    ):
10044        self.account_id = account_id if account_id is not None else ''
10045        '''
10046         The account for this remote identity.
10047        '''
10048        self.id = id if id is not None else ''
10049        '''
10050         Unique identifier of the RemoteIdentity.
10051        '''
10052        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10053        '''
10054         The remote identity group.
10055        '''
10056        self.username = username if username is not None else ''
10057        '''
10058         The username to be used as the remote identity for this account.
10059        '''
10060
10061    def __repr__(self):
10062        return '<sdm.RemoteIdentity ' + \
10063            'account_id: ' + repr(self.account_id) + ' ' +\
10064            'id: ' + repr(self.id) + ' ' +\
10065            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10066            'username: ' + repr(self.username) + ' ' +\
10067            '>'
10068
10069    def to_dict(self):
10070        return {
10071            'account_id': self.account_id,
10072            'id': self.id,
10073            'remote_identity_group_id': self.remote_identity_group_id,
10074            'username': self.username,
10075        }
10076
10077    @classmethod
10078    def from_dict(cls, d):
10079        return cls(
10080            account_id=d.get('account_id'),
10081            id=d.get('id'),
10082            remote_identity_group_id=d.get('remote_identity_group_id'),
10083            username=d.get('username'),
10084        )
10085
10086
10087class RemoteIdentityCreateResponse:
10088    '''
10089         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10090    '''
10091    __slots__ = [
10092        'meta',
10093        'rate_limit',
10094        'remote_identity',
10095    ]
10096
10097    def __init__(
10098        self,
10099        meta=None,
10100        rate_limit=None,
10101        remote_identity=None,
10102    ):
10103        self.meta = meta if meta is not None else None
10104        '''
10105         Reserved for future use.
10106        '''
10107        self.rate_limit = rate_limit if rate_limit is not None else None
10108        '''
10109         Rate limit information.
10110        '''
10111        self.remote_identity = remote_identity if remote_identity is not None else None
10112        '''
10113         The created RemoteIdentity.
10114        '''
10115
10116    def __repr__(self):
10117        return '<sdm.RemoteIdentityCreateResponse ' + \
10118            'meta: ' + repr(self.meta) + ' ' +\
10119            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10120            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10121            '>'
10122
10123    def to_dict(self):
10124        return {
10125            'meta': self.meta,
10126            'rate_limit': self.rate_limit,
10127            'remote_identity': self.remote_identity,
10128        }
10129
10130    @classmethod
10131    def from_dict(cls, d):
10132        return cls(
10133            meta=d.get('meta'),
10134            rate_limit=d.get('rate_limit'),
10135            remote_identity=d.get('remote_identity'),
10136        )
10137
10138
10139class RemoteIdentityDeleteResponse:
10140    '''
10141         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10142    '''
10143    __slots__ = [
10144        'meta',
10145        'rate_limit',
10146    ]
10147
10148    def __init__(
10149        self,
10150        meta=None,
10151        rate_limit=None,
10152    ):
10153        self.meta = meta if meta is not None else None
10154        '''
10155         Reserved for future use.
10156        '''
10157        self.rate_limit = rate_limit if rate_limit is not None else None
10158        '''
10159         Rate limit information.
10160        '''
10161
10162    def __repr__(self):
10163        return '<sdm.RemoteIdentityDeleteResponse ' + \
10164            'meta: ' + repr(self.meta) + ' ' +\
10165            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10166            '>'
10167
10168    def to_dict(self):
10169        return {
10170            'meta': self.meta,
10171            'rate_limit': self.rate_limit,
10172        }
10173
10174    @classmethod
10175    def from_dict(cls, d):
10176        return cls(
10177            meta=d.get('meta'),
10178            rate_limit=d.get('rate_limit'),
10179        )
10180
10181
10182class RemoteIdentityGetResponse:
10183    '''
10184         RemoteIdentityGetResponse returns a requested RemoteIdentity.
10185    '''
10186    __slots__ = [
10187        'meta',
10188        'rate_limit',
10189        'remote_identity',
10190    ]
10191
10192    def __init__(
10193        self,
10194        meta=None,
10195        rate_limit=None,
10196        remote_identity=None,
10197    ):
10198        self.meta = meta if meta is not None else None
10199        '''
10200         Reserved for future use.
10201        '''
10202        self.rate_limit = rate_limit if rate_limit is not None else None
10203        '''
10204         Rate limit information.
10205        '''
10206        self.remote_identity = remote_identity if remote_identity is not None else None
10207        '''
10208         The requested RemoteIdentity.
10209        '''
10210
10211    def __repr__(self):
10212        return '<sdm.RemoteIdentityGetResponse ' + \
10213            'meta: ' + repr(self.meta) + ' ' +\
10214            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10215            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10216            '>'
10217
10218    def to_dict(self):
10219        return {
10220            'meta': self.meta,
10221            'rate_limit': self.rate_limit,
10222            'remote_identity': self.remote_identity,
10223        }
10224
10225    @classmethod
10226    def from_dict(cls, d):
10227        return cls(
10228            meta=d.get('meta'),
10229            rate_limit=d.get('rate_limit'),
10230            remote_identity=d.get('remote_identity'),
10231        )
10232
10233
10234class RemoteIdentityGroup:
10235    '''
10236         A RemoteIdentityGroup defines a group of remote identities.
10237    '''
10238    __slots__ = [
10239        'id',
10240        'name',
10241    ]
10242
10243    def __init__(
10244        self,
10245        id=None,
10246        name=None,
10247    ):
10248        self.id = id if id is not None else ''
10249        '''
10250         Unique identifier of the RemoteIdentityGroup.
10251        '''
10252        self.name = name if name is not None else ''
10253        '''
10254         Unique human-readable name of the RemoteIdentityGroup.
10255        '''
10256
10257    def __repr__(self):
10258        return '<sdm.RemoteIdentityGroup ' + \
10259            'id: ' + repr(self.id) + ' ' +\
10260            'name: ' + repr(self.name) + ' ' +\
10261            '>'
10262
10263    def to_dict(self):
10264        return {
10265            'id': self.id,
10266            'name': self.name,
10267        }
10268
10269    @classmethod
10270    def from_dict(cls, d):
10271        return cls(
10272            id=d.get('id'),
10273            name=d.get('name'),
10274        )
10275
10276
10277class RemoteIdentityGroupGetResponse:
10278    '''
10279         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10280    '''
10281    __slots__ = [
10282        'meta',
10283        'rate_limit',
10284        'remote_identity_group',
10285    ]
10286
10287    def __init__(
10288        self,
10289        meta=None,
10290        rate_limit=None,
10291        remote_identity_group=None,
10292    ):
10293        self.meta = meta if meta is not None else None
10294        '''
10295         Reserved for future use.
10296        '''
10297        self.rate_limit = rate_limit if rate_limit is not None else None
10298        '''
10299         Rate limit information.
10300        '''
10301        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10302        '''
10303         The requested RemoteIdentityGroup.
10304        '''
10305
10306    def __repr__(self):
10307        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10308            'meta: ' + repr(self.meta) + ' ' +\
10309            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10310            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10311            '>'
10312
10313    def to_dict(self):
10314        return {
10315            'meta': self.meta,
10316            'rate_limit': self.rate_limit,
10317            'remote_identity_group': self.remote_identity_group,
10318        }
10319
10320    @classmethod
10321    def from_dict(cls, d):
10322        return cls(
10323            meta=d.get('meta'),
10324            rate_limit=d.get('rate_limit'),
10325            remote_identity_group=d.get('remote_identity_group'),
10326        )
10327
10328
10329class RemoteIdentityUpdateResponse:
10330    '''
10331         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10332     a RemoteIdentityUpdateRequest.
10333    '''
10334    __slots__ = [
10335        'meta',
10336        'rate_limit',
10337        'remote_identity',
10338    ]
10339
10340    def __init__(
10341        self,
10342        meta=None,
10343        rate_limit=None,
10344        remote_identity=None,
10345    ):
10346        self.meta = meta if meta is not None else None
10347        '''
10348         Reserved for future use.
10349        '''
10350        self.rate_limit = rate_limit if rate_limit is not None else None
10351        '''
10352         Rate limit information.
10353        '''
10354        self.remote_identity = remote_identity if remote_identity is not None else None
10355        '''
10356         The updated RemoteIdentity.
10357        '''
10358
10359    def __repr__(self):
10360        return '<sdm.RemoteIdentityUpdateResponse ' + \
10361            'meta: ' + repr(self.meta) + ' ' +\
10362            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10363            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10364            '>'
10365
10366    def to_dict(self):
10367        return {
10368            'meta': self.meta,
10369            'rate_limit': self.rate_limit,
10370            'remote_identity': self.remote_identity,
10371        }
10372
10373    @classmethod
10374    def from_dict(cls, d):
10375        return cls(
10376            meta=d.get('meta'),
10377            rate_limit=d.get('rate_limit'),
10378            remote_identity=d.get('remote_identity'),
10379        )
10380
10381
10382class ResourceCreateResponse:
10383    '''
10384         ResourceCreateResponse reports how the Resources were created in the system.
10385    '''
10386    __slots__ = [
10387        'meta',
10388        'rate_limit',
10389        'resource',
10390    ]
10391
10392    def __init__(
10393        self,
10394        meta=None,
10395        rate_limit=None,
10396        resource=None,
10397    ):
10398        self.meta = meta if meta is not None else None
10399        '''
10400         Reserved for future use.
10401        '''
10402        self.rate_limit = rate_limit if rate_limit is not None else None
10403        '''
10404         Rate limit information.
10405        '''
10406        self.resource = resource if resource is not None else None
10407        '''
10408         The created Resource.
10409        '''
10410
10411    def __repr__(self):
10412        return '<sdm.ResourceCreateResponse ' + \
10413            'meta: ' + repr(self.meta) + ' ' +\
10414            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10415            'resource: ' + repr(self.resource) + ' ' +\
10416            '>'
10417
10418    def to_dict(self):
10419        return {
10420            'meta': self.meta,
10421            'rate_limit': self.rate_limit,
10422            'resource': self.resource,
10423        }
10424
10425    @classmethod
10426    def from_dict(cls, d):
10427        return cls(
10428            meta=d.get('meta'),
10429            rate_limit=d.get('rate_limit'),
10430            resource=d.get('resource'),
10431        )
10432
10433
10434class ResourceDeleteResponse:
10435    '''
10436         ResourceDeleteResponse returns information about a Resource that was deleted.
10437    '''
10438    __slots__ = [
10439        'meta',
10440        'rate_limit',
10441    ]
10442
10443    def __init__(
10444        self,
10445        meta=None,
10446        rate_limit=None,
10447    ):
10448        self.meta = meta if meta is not None else None
10449        '''
10450         Reserved for future use.
10451        '''
10452        self.rate_limit = rate_limit if rate_limit is not None else None
10453        '''
10454         Rate limit information.
10455        '''
10456
10457    def __repr__(self):
10458        return '<sdm.ResourceDeleteResponse ' + \
10459            'meta: ' + repr(self.meta) + ' ' +\
10460            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10461            '>'
10462
10463    def to_dict(self):
10464        return {
10465            'meta': self.meta,
10466            'rate_limit': self.rate_limit,
10467        }
10468
10469    @classmethod
10470    def from_dict(cls, d):
10471        return cls(
10472            meta=d.get('meta'),
10473            rate_limit=d.get('rate_limit'),
10474        )
10475
10476
10477class ResourceGetResponse:
10478    '''
10479         ResourceGetResponse returns a requested Resource.
10480    '''
10481    __slots__ = [
10482        'meta',
10483        'rate_limit',
10484        'resource',
10485    ]
10486
10487    def __init__(
10488        self,
10489        meta=None,
10490        rate_limit=None,
10491        resource=None,
10492    ):
10493        self.meta = meta if meta is not None else None
10494        '''
10495         Reserved for future use.
10496        '''
10497        self.rate_limit = rate_limit if rate_limit is not None else None
10498        '''
10499         Rate limit information.
10500        '''
10501        self.resource = resource if resource is not None else None
10502        '''
10503         The requested Resource.
10504        '''
10505
10506    def __repr__(self):
10507        return '<sdm.ResourceGetResponse ' + \
10508            'meta: ' + repr(self.meta) + ' ' +\
10509            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10510            'resource: ' + repr(self.resource) + ' ' +\
10511            '>'
10512
10513    def to_dict(self):
10514        return {
10515            'meta': self.meta,
10516            'rate_limit': self.rate_limit,
10517            'resource': self.resource,
10518        }
10519
10520    @classmethod
10521    def from_dict(cls, d):
10522        return cls(
10523            meta=d.get('meta'),
10524            rate_limit=d.get('rate_limit'),
10525            resource=d.get('resource'),
10526        )
10527
10528
10529class ResourceUpdateResponse:
10530    '''
10531         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10532     a ResourceUpdateRequest.
10533    '''
10534    __slots__ = [
10535        'meta',
10536        'rate_limit',
10537        'resource',
10538    ]
10539
10540    def __init__(
10541        self,
10542        meta=None,
10543        rate_limit=None,
10544        resource=None,
10545    ):
10546        self.meta = meta if meta is not None else None
10547        '''
10548         Reserved for future use.
10549        '''
10550        self.rate_limit = rate_limit if rate_limit is not None else None
10551        '''
10552         Rate limit information.
10553        '''
10554        self.resource = resource if resource is not None else None
10555        '''
10556         The updated Resource.
10557        '''
10558
10559    def __repr__(self):
10560        return '<sdm.ResourceUpdateResponse ' + \
10561            'meta: ' + repr(self.meta) + ' ' +\
10562            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10563            'resource: ' + repr(self.resource) + ' ' +\
10564            '>'
10565
10566    def to_dict(self):
10567        return {
10568            'meta': self.meta,
10569            'rate_limit': self.rate_limit,
10570            'resource': self.resource,
10571        }
10572
10573    @classmethod
10574    def from_dict(cls, d):
10575        return cls(
10576            meta=d.get('meta'),
10577            rate_limit=d.get('rate_limit'),
10578            resource=d.get('resource'),
10579        )
10580
10581
10582class Role:
10583    '''
10584         A Role has a list of access rules which determine which Resources the members
10585     of the Role have access to. An Account can be a member of multiple Roles via
10586     AccountAttachments.
10587    '''
10588    __slots__ = [
10589        'access_rules',
10590        'id',
10591        'managed_by',
10592        'name',
10593        'tags',
10594    ]
10595
10596    def __init__(
10597        self,
10598        access_rules=None,
10599        id=None,
10600        managed_by=None,
10601        name=None,
10602        tags=None,
10603    ):
10604        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10605        )
10606        '''
10607         AccessRules is a list of access rules defining the resources this Role has access to.
10608        '''
10609        self.id = id if id is not None else ''
10610        '''
10611         Unique identifier of the Role.
10612        '''
10613        self.managed_by = managed_by if managed_by is not None else ''
10614        '''
10615         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10616        '''
10617        self.name = name if name is not None else ''
10618        '''
10619         Unique human-readable name of the Role.
10620        '''
10621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10622        '''
10623         Tags is a map of key, value pairs.
10624        '''
10625
10626    def __repr__(self):
10627        return '<sdm.Role ' + \
10628            'access_rules: ' + repr(self.access_rules) + ' ' +\
10629            'id: ' + repr(self.id) + ' ' +\
10630            'managed_by: ' + repr(self.managed_by) + ' ' +\
10631            'name: ' + repr(self.name) + ' ' +\
10632            'tags: ' + repr(self.tags) + ' ' +\
10633            '>'
10634
10635    def to_dict(self):
10636        return {
10637            'access_rules': self.access_rules,
10638            'id': self.id,
10639            'managed_by': self.managed_by,
10640            'name': self.name,
10641            'tags': self.tags,
10642        }
10643
10644    @classmethod
10645    def from_dict(cls, d):
10646        return cls(
10647            access_rules=d.get('access_rules'),
10648            id=d.get('id'),
10649            managed_by=d.get('managed_by'),
10650            name=d.get('name'),
10651            tags=d.get('tags'),
10652        )
10653
10654
10655class RoleCreateResponse:
10656    '''
10657         RoleCreateResponse reports how the Roles were created in the system. It can
10658     communicate partial successes or failures.
10659    '''
10660    __slots__ = [
10661        'meta',
10662        'rate_limit',
10663        'role',
10664    ]
10665
10666    def __init__(
10667        self,
10668        meta=None,
10669        rate_limit=None,
10670        role=None,
10671    ):
10672        self.meta = meta if meta is not None else None
10673        '''
10674         Reserved for future use.
10675        '''
10676        self.rate_limit = rate_limit if rate_limit is not None else None
10677        '''
10678         Rate limit information.
10679        '''
10680        self.role = role if role is not None else None
10681        '''
10682         The created Role.
10683        '''
10684
10685    def __repr__(self):
10686        return '<sdm.RoleCreateResponse ' + \
10687            'meta: ' + repr(self.meta) + ' ' +\
10688            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10689            'role: ' + repr(self.role) + ' ' +\
10690            '>'
10691
10692    def to_dict(self):
10693        return {
10694            'meta': self.meta,
10695            'rate_limit': self.rate_limit,
10696            'role': self.role,
10697        }
10698
10699    @classmethod
10700    def from_dict(cls, d):
10701        return cls(
10702            meta=d.get('meta'),
10703            rate_limit=d.get('rate_limit'),
10704            role=d.get('role'),
10705        )
10706
10707
10708class RoleDeleteResponse:
10709    '''
10710         RoleDeleteResponse returns information about a Role that was deleted.
10711    '''
10712    __slots__ = [
10713        'meta',
10714        'rate_limit',
10715    ]
10716
10717    def __init__(
10718        self,
10719        meta=None,
10720        rate_limit=None,
10721    ):
10722        self.meta = meta if meta is not None else None
10723        '''
10724         Reserved for future use.
10725        '''
10726        self.rate_limit = rate_limit if rate_limit is not None else None
10727        '''
10728         Rate limit information.
10729        '''
10730
10731    def __repr__(self):
10732        return '<sdm.RoleDeleteResponse ' + \
10733            'meta: ' + repr(self.meta) + ' ' +\
10734            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10735            '>'
10736
10737    def to_dict(self):
10738        return {
10739            'meta': self.meta,
10740            'rate_limit': self.rate_limit,
10741        }
10742
10743    @classmethod
10744    def from_dict(cls, d):
10745        return cls(
10746            meta=d.get('meta'),
10747            rate_limit=d.get('rate_limit'),
10748        )
10749
10750
10751class RoleGetResponse:
10752    '''
10753         RoleGetResponse returns a requested Role.
10754    '''
10755    __slots__ = [
10756        'meta',
10757        'rate_limit',
10758        'role',
10759    ]
10760
10761    def __init__(
10762        self,
10763        meta=None,
10764        rate_limit=None,
10765        role=None,
10766    ):
10767        self.meta = meta if meta is not None else None
10768        '''
10769         Reserved for future use.
10770        '''
10771        self.rate_limit = rate_limit if rate_limit is not None else None
10772        '''
10773         Rate limit information.
10774        '''
10775        self.role = role if role is not None else None
10776        '''
10777         The requested Role.
10778        '''
10779
10780    def __repr__(self):
10781        return '<sdm.RoleGetResponse ' + \
10782            'meta: ' + repr(self.meta) + ' ' +\
10783            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10784            'role: ' + repr(self.role) + ' ' +\
10785            '>'
10786
10787    def to_dict(self):
10788        return {
10789            'meta': self.meta,
10790            'rate_limit': self.rate_limit,
10791            'role': self.role,
10792        }
10793
10794    @classmethod
10795    def from_dict(cls, d):
10796        return cls(
10797            meta=d.get('meta'),
10798            rate_limit=d.get('rate_limit'),
10799            role=d.get('role'),
10800        )
10801
10802
10803class RoleUpdateResponse:
10804    '''
10805         RoleUpdateResponse returns the fields of a Role after it has been updated by
10806     a RoleUpdateRequest.
10807    '''
10808    __slots__ = [
10809        'meta',
10810        'rate_limit',
10811        'role',
10812    ]
10813
10814    def __init__(
10815        self,
10816        meta=None,
10817        rate_limit=None,
10818        role=None,
10819    ):
10820        self.meta = meta if meta is not None else None
10821        '''
10822         Reserved for future use.
10823        '''
10824        self.rate_limit = rate_limit if rate_limit is not None else None
10825        '''
10826         Rate limit information.
10827        '''
10828        self.role = role if role is not None else None
10829        '''
10830         The updated Role.
10831        '''
10832
10833    def __repr__(self):
10834        return '<sdm.RoleUpdateResponse ' + \
10835            'meta: ' + repr(self.meta) + ' ' +\
10836            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10837            'role: ' + repr(self.role) + ' ' +\
10838            '>'
10839
10840    def to_dict(self):
10841        return {
10842            'meta': self.meta,
10843            'rate_limit': self.rate_limit,
10844            'role': self.role,
10845        }
10846
10847    @classmethod
10848    def from_dict(cls, d):
10849        return cls(
10850            meta=d.get('meta'),
10851            rate_limit=d.get('rate_limit'),
10852            role=d.get('role'),
10853        )
10854
10855
10856class SQLServer:
10857    __slots__ = [
10858        'bind_interface',
10859        'database',
10860        'egress_filter',
10861        'healthy',
10862        'hostname',
10863        'id',
10864        'name',
10865        'override_database',
10866        'password',
10867        'port',
10868        'port_override',
10869        'schema',
10870        'secret_store_id',
10871        'tags',
10872        'username',
10873    ]
10874
10875    def __init__(
10876        self,
10877        bind_interface=None,
10878        database=None,
10879        egress_filter=None,
10880        healthy=None,
10881        hostname=None,
10882        id=None,
10883        name=None,
10884        override_database=None,
10885        password=None,
10886        port=None,
10887        port_override=None,
10888        schema=None,
10889        secret_store_id=None,
10890        tags=None,
10891        username=None,
10892    ):
10893        self.bind_interface = bind_interface if bind_interface is not None else ''
10894        '''
10895         Bind interface
10896        '''
10897        self.database = database if database is not None else ''
10898        self.egress_filter = egress_filter if egress_filter is not None else ''
10899        '''
10900         A filter applied to the routing logic to pin datasource to nodes.
10901        '''
10902        self.healthy = healthy if healthy is not None else False
10903        '''
10904         True if the datasource is reachable and the credentials are valid.
10905        '''
10906        self.hostname = hostname if hostname is not None else ''
10907        self.id = id if id is not None else ''
10908        '''
10909         Unique identifier of the Resource.
10910        '''
10911        self.name = name if name is not None else ''
10912        '''
10913         Unique human-readable name of the Resource.
10914        '''
10915        self.override_database = override_database if override_database is not None else False
10916        self.password = password if password is not None else ''
10917        self.port = port if port is not None else 0
10918        self.port_override = port_override if port_override is not None else 0
10919        self.schema = schema if schema is not None else ''
10920        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10921        '''
10922         ID of the secret store containing credentials for this resource, if any.
10923        '''
10924        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10925        '''
10926         Tags is a map of key, value pairs.
10927        '''
10928        self.username = username if username is not None else ''
10929
10930    def __repr__(self):
10931        return '<sdm.SQLServer ' + \
10932            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10933            'database: ' + repr(self.database) + ' ' +\
10934            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10935            'healthy: ' + repr(self.healthy) + ' ' +\
10936            'hostname: ' + repr(self.hostname) + ' ' +\
10937            'id: ' + repr(self.id) + ' ' +\
10938            'name: ' + repr(self.name) + ' ' +\
10939            'override_database: ' + repr(self.override_database) + ' ' +\
10940            'password: ' + repr(self.password) + ' ' +\
10941            'port: ' + repr(self.port) + ' ' +\
10942            'port_override: ' + repr(self.port_override) + ' ' +\
10943            'schema: ' + repr(self.schema) + ' ' +\
10944            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10945            'tags: ' + repr(self.tags) + ' ' +\
10946            'username: ' + repr(self.username) + ' ' +\
10947            '>'
10948
10949    def to_dict(self):
10950        return {
10951            'bind_interface': self.bind_interface,
10952            'database': self.database,
10953            'egress_filter': self.egress_filter,
10954            'healthy': self.healthy,
10955            'hostname': self.hostname,
10956            'id': self.id,
10957            'name': self.name,
10958            'override_database': self.override_database,
10959            'password': self.password,
10960            'port': self.port,
10961            'port_override': self.port_override,
10962            'schema': self.schema,
10963            'secret_store_id': self.secret_store_id,
10964            'tags': self.tags,
10965            'username': self.username,
10966        }
10967
10968    @classmethod
10969    def from_dict(cls, d):
10970        return cls(
10971            bind_interface=d.get('bind_interface'),
10972            database=d.get('database'),
10973            egress_filter=d.get('egress_filter'),
10974            healthy=d.get('healthy'),
10975            hostname=d.get('hostname'),
10976            id=d.get('id'),
10977            name=d.get('name'),
10978            override_database=d.get('override_database'),
10979            password=d.get('password'),
10980            port=d.get('port'),
10981            port_override=d.get('port_override'),
10982            schema=d.get('schema'),
10983            secret_store_id=d.get('secret_store_id'),
10984            tags=d.get('tags'),
10985            username=d.get('username'),
10986        )
10987
10988
10989class SSH:
10990    __slots__ = [
10991        'allow_deprecated_key_exchanges',
10992        'bind_interface',
10993        'egress_filter',
10994        'healthy',
10995        'hostname',
10996        'id',
10997        'key_type',
10998        'name',
10999        'port',
11000        'port_forwarding',
11001        'port_override',
11002        'public_key',
11003        'secret_store_id',
11004        'tags',
11005        'username',
11006    ]
11007
11008    def __init__(
11009        self,
11010        allow_deprecated_key_exchanges=None,
11011        bind_interface=None,
11012        egress_filter=None,
11013        healthy=None,
11014        hostname=None,
11015        id=None,
11016        key_type=None,
11017        name=None,
11018        port=None,
11019        port_forwarding=None,
11020        port_override=None,
11021        public_key=None,
11022        secret_store_id=None,
11023        tags=None,
11024        username=None,
11025    ):
11026        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11027        self.bind_interface = bind_interface if bind_interface is not None else ''
11028        '''
11029         Bind interface
11030        '''
11031        self.egress_filter = egress_filter if egress_filter is not None else ''
11032        '''
11033         A filter applied to the routing logic to pin datasource to nodes.
11034        '''
11035        self.healthy = healthy if healthy is not None else False
11036        '''
11037         True if the datasource is reachable and the credentials are valid.
11038        '''
11039        self.hostname = hostname if hostname is not None else ''
11040        self.id = id if id is not None else ''
11041        '''
11042         Unique identifier of the Resource.
11043        '''
11044        self.key_type = key_type if key_type is not None else ''
11045        self.name = name if name is not None else ''
11046        '''
11047         Unique human-readable name of the Resource.
11048        '''
11049        self.port = port if port is not None else 0
11050        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11051        self.port_override = port_override if port_override is not None else 0
11052        self.public_key = public_key if public_key is not None else ''
11053        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11054        '''
11055         ID of the secret store containing credentials for this resource, if any.
11056        '''
11057        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11058        '''
11059         Tags is a map of key, value pairs.
11060        '''
11061        self.username = username if username is not None else ''
11062
11063    def __repr__(self):
11064        return '<sdm.SSH ' + \
11065            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11066            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11067            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11068            'healthy: ' + repr(self.healthy) + ' ' +\
11069            'hostname: ' + repr(self.hostname) + ' ' +\
11070            'id: ' + repr(self.id) + ' ' +\
11071            'key_type: ' + repr(self.key_type) + ' ' +\
11072            'name: ' + repr(self.name) + ' ' +\
11073            'port: ' + repr(self.port) + ' ' +\
11074            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11075            'port_override: ' + repr(self.port_override) + ' ' +\
11076            'public_key: ' + repr(self.public_key) + ' ' +\
11077            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11078            'tags: ' + repr(self.tags) + ' ' +\
11079            'username: ' + repr(self.username) + ' ' +\
11080            '>'
11081
11082    def to_dict(self):
11083        return {
11084            'allow_deprecated_key_exchanges':
11085            self.allow_deprecated_key_exchanges,
11086            'bind_interface': self.bind_interface,
11087            'egress_filter': self.egress_filter,
11088            'healthy': self.healthy,
11089            'hostname': self.hostname,
11090            'id': self.id,
11091            'key_type': self.key_type,
11092            'name': self.name,
11093            'port': self.port,
11094            'port_forwarding': self.port_forwarding,
11095            'port_override': self.port_override,
11096            'public_key': self.public_key,
11097            'secret_store_id': self.secret_store_id,
11098            'tags': self.tags,
11099            'username': self.username,
11100        }
11101
11102    @classmethod
11103    def from_dict(cls, d):
11104        return cls(
11105            allow_deprecated_key_exchanges=d.get(
11106                'allow_deprecated_key_exchanges'),
11107            bind_interface=d.get('bind_interface'),
11108            egress_filter=d.get('egress_filter'),
11109            healthy=d.get('healthy'),
11110            hostname=d.get('hostname'),
11111            id=d.get('id'),
11112            key_type=d.get('key_type'),
11113            name=d.get('name'),
11114            port=d.get('port'),
11115            port_forwarding=d.get('port_forwarding'),
11116            port_override=d.get('port_override'),
11117            public_key=d.get('public_key'),
11118            secret_store_id=d.get('secret_store_id'),
11119            tags=d.get('tags'),
11120            username=d.get('username'),
11121        )
11122
11123
11124class SSHCert:
11125    __slots__ = [
11126        'allow_deprecated_key_exchanges',
11127        'bind_interface',
11128        'egress_filter',
11129        'healthy',
11130        'hostname',
11131        'id',
11132        'key_type',
11133        'name',
11134        'port',
11135        'port_forwarding',
11136        'port_override',
11137        'remote_identity_group_id',
11138        'remote_identity_healthcheck_username',
11139        'secret_store_id',
11140        'tags',
11141        'username',
11142    ]
11143
11144    def __init__(
11145        self,
11146        allow_deprecated_key_exchanges=None,
11147        bind_interface=None,
11148        egress_filter=None,
11149        healthy=None,
11150        hostname=None,
11151        id=None,
11152        key_type=None,
11153        name=None,
11154        port=None,
11155        port_forwarding=None,
11156        port_override=None,
11157        remote_identity_group_id=None,
11158        remote_identity_healthcheck_username=None,
11159        secret_store_id=None,
11160        tags=None,
11161        username=None,
11162    ):
11163        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11164        self.bind_interface = bind_interface if bind_interface is not None else ''
11165        '''
11166         Bind interface
11167        '''
11168        self.egress_filter = egress_filter if egress_filter is not None else ''
11169        '''
11170         A filter applied to the routing logic to pin datasource to nodes.
11171        '''
11172        self.healthy = healthy if healthy is not None else False
11173        '''
11174         True if the datasource is reachable and the credentials are valid.
11175        '''
11176        self.hostname = hostname if hostname is not None else ''
11177        self.id = id if id is not None else ''
11178        '''
11179         Unique identifier of the Resource.
11180        '''
11181        self.key_type = key_type if key_type is not None else ''
11182        self.name = name if name is not None else ''
11183        '''
11184         Unique human-readable name of the Resource.
11185        '''
11186        self.port = port if port is not None else 0
11187        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11188        self.port_override = port_override if port_override is not None else 0
11189        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11190        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11191        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11192        '''
11193         ID of the secret store containing credentials for this resource, if any.
11194        '''
11195        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11196        '''
11197         Tags is a map of key, value pairs.
11198        '''
11199        self.username = username if username is not None else ''
11200
11201    def __repr__(self):
11202        return '<sdm.SSHCert ' + \
11203            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11204            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11205            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11206            'healthy: ' + repr(self.healthy) + ' ' +\
11207            'hostname: ' + repr(self.hostname) + ' ' +\
11208            'id: ' + repr(self.id) + ' ' +\
11209            'key_type: ' + repr(self.key_type) + ' ' +\
11210            'name: ' + repr(self.name) + ' ' +\
11211            'port: ' + repr(self.port) + ' ' +\
11212            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11213            'port_override: ' + repr(self.port_override) + ' ' +\
11214            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11215            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11216            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11217            'tags: ' + repr(self.tags) + ' ' +\
11218            'username: ' + repr(self.username) + ' ' +\
11219            '>'
11220
11221    def to_dict(self):
11222        return {
11223            'allow_deprecated_key_exchanges':
11224            self.allow_deprecated_key_exchanges,
11225            'bind_interface': self.bind_interface,
11226            'egress_filter': self.egress_filter,
11227            'healthy': self.healthy,
11228            'hostname': self.hostname,
11229            'id': self.id,
11230            'key_type': self.key_type,
11231            'name': self.name,
11232            'port': self.port,
11233            'port_forwarding': self.port_forwarding,
11234            'port_override': self.port_override,
11235            'remote_identity_group_id': self.remote_identity_group_id,
11236            'remote_identity_healthcheck_username':
11237            self.remote_identity_healthcheck_username,
11238            'secret_store_id': self.secret_store_id,
11239            'tags': self.tags,
11240            'username': self.username,
11241        }
11242
11243    @classmethod
11244    def from_dict(cls, d):
11245        return cls(
11246            allow_deprecated_key_exchanges=d.get(
11247                'allow_deprecated_key_exchanges'),
11248            bind_interface=d.get('bind_interface'),
11249            egress_filter=d.get('egress_filter'),
11250            healthy=d.get('healthy'),
11251            hostname=d.get('hostname'),
11252            id=d.get('id'),
11253            key_type=d.get('key_type'),
11254            name=d.get('name'),
11255            port=d.get('port'),
11256            port_forwarding=d.get('port_forwarding'),
11257            port_override=d.get('port_override'),
11258            remote_identity_group_id=d.get('remote_identity_group_id'),
11259            remote_identity_healthcheck_username=d.get(
11260                'remote_identity_healthcheck_username'),
11261            secret_store_id=d.get('secret_store_id'),
11262            tags=d.get('tags'),
11263            username=d.get('username'),
11264        )
11265
11266
11267class SSHCustomerKey:
11268    __slots__ = [
11269        'allow_deprecated_key_exchanges',
11270        'bind_interface',
11271        'egress_filter',
11272        'healthy',
11273        'hostname',
11274        'id',
11275        'name',
11276        'port',
11277        'port_forwarding',
11278        'port_override',
11279        'private_key',
11280        'secret_store_id',
11281        'tags',
11282        'username',
11283    ]
11284
11285    def __init__(
11286        self,
11287        allow_deprecated_key_exchanges=None,
11288        bind_interface=None,
11289        egress_filter=None,
11290        healthy=None,
11291        hostname=None,
11292        id=None,
11293        name=None,
11294        port=None,
11295        port_forwarding=None,
11296        port_override=None,
11297        private_key=None,
11298        secret_store_id=None,
11299        tags=None,
11300        username=None,
11301    ):
11302        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11303        self.bind_interface = bind_interface if bind_interface is not None else ''
11304        '''
11305         Bind interface
11306        '''
11307        self.egress_filter = egress_filter if egress_filter is not None else ''
11308        '''
11309         A filter applied to the routing logic to pin datasource to nodes.
11310        '''
11311        self.healthy = healthy if healthy is not None else False
11312        '''
11313         True if the datasource is reachable and the credentials are valid.
11314        '''
11315        self.hostname = hostname if hostname is not None else ''
11316        self.id = id if id is not None else ''
11317        '''
11318         Unique identifier of the Resource.
11319        '''
11320        self.name = name if name is not None else ''
11321        '''
11322         Unique human-readable name of the Resource.
11323        '''
11324        self.port = port if port is not None else 0
11325        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11326        self.port_override = port_override if port_override is not None else 0
11327        self.private_key = private_key if private_key is not None else ''
11328        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11329        '''
11330         ID of the secret store containing credentials for this resource, if any.
11331        '''
11332        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11333        '''
11334         Tags is a map of key, value pairs.
11335        '''
11336        self.username = username if username is not None else ''
11337
11338    def __repr__(self):
11339        return '<sdm.SSHCustomerKey ' + \
11340            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11341            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11342            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11343            'healthy: ' + repr(self.healthy) + ' ' +\
11344            'hostname: ' + repr(self.hostname) + ' ' +\
11345            'id: ' + repr(self.id) + ' ' +\
11346            'name: ' + repr(self.name) + ' ' +\
11347            'port: ' + repr(self.port) + ' ' +\
11348            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11349            'port_override: ' + repr(self.port_override) + ' ' +\
11350            'private_key: ' + repr(self.private_key) + ' ' +\
11351            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11352            'tags: ' + repr(self.tags) + ' ' +\
11353            'username: ' + repr(self.username) + ' ' +\
11354            '>'
11355
11356    def to_dict(self):
11357        return {
11358            'allow_deprecated_key_exchanges':
11359            self.allow_deprecated_key_exchanges,
11360            'bind_interface': self.bind_interface,
11361            'egress_filter': self.egress_filter,
11362            'healthy': self.healthy,
11363            'hostname': self.hostname,
11364            'id': self.id,
11365            'name': self.name,
11366            'port': self.port,
11367            'port_forwarding': self.port_forwarding,
11368            'port_override': self.port_override,
11369            'private_key': self.private_key,
11370            'secret_store_id': self.secret_store_id,
11371            'tags': self.tags,
11372            'username': self.username,
11373        }
11374
11375    @classmethod
11376    def from_dict(cls, d):
11377        return cls(
11378            allow_deprecated_key_exchanges=d.get(
11379                'allow_deprecated_key_exchanges'),
11380            bind_interface=d.get('bind_interface'),
11381            egress_filter=d.get('egress_filter'),
11382            healthy=d.get('healthy'),
11383            hostname=d.get('hostname'),
11384            id=d.get('id'),
11385            name=d.get('name'),
11386            port=d.get('port'),
11387            port_forwarding=d.get('port_forwarding'),
11388            port_override=d.get('port_override'),
11389            private_key=d.get('private_key'),
11390            secret_store_id=d.get('secret_store_id'),
11391            tags=d.get('tags'),
11392            username=d.get('username'),
11393        )
11394
11395
11396class SecretStoreCreateResponse:
11397    '''
11398         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11399    '''
11400    __slots__ = [
11401        'meta',
11402        'rate_limit',
11403        'secret_store',
11404    ]
11405
11406    def __init__(
11407        self,
11408        meta=None,
11409        rate_limit=None,
11410        secret_store=None,
11411    ):
11412        self.meta = meta if meta is not None else None
11413        '''
11414         Reserved for future use.
11415        '''
11416        self.rate_limit = rate_limit if rate_limit is not None else None
11417        '''
11418         Rate limit information.
11419        '''
11420        self.secret_store = secret_store if secret_store is not None else None
11421        '''
11422         The created SecretStore.
11423        '''
11424
11425    def __repr__(self):
11426        return '<sdm.SecretStoreCreateResponse ' + \
11427            'meta: ' + repr(self.meta) + ' ' +\
11428            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11429            'secret_store: ' + repr(self.secret_store) + ' ' +\
11430            '>'
11431
11432    def to_dict(self):
11433        return {
11434            'meta': self.meta,
11435            'rate_limit': self.rate_limit,
11436            'secret_store': self.secret_store,
11437        }
11438
11439    @classmethod
11440    def from_dict(cls, d):
11441        return cls(
11442            meta=d.get('meta'),
11443            rate_limit=d.get('rate_limit'),
11444            secret_store=d.get('secret_store'),
11445        )
11446
11447
11448class SecretStoreDeleteResponse:
11449    '''
11450         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11451    '''
11452    __slots__ = [
11453        'meta',
11454        'rate_limit',
11455    ]
11456
11457    def __init__(
11458        self,
11459        meta=None,
11460        rate_limit=None,
11461    ):
11462        self.meta = meta if meta is not None else None
11463        '''
11464         Reserved for future use.
11465        '''
11466        self.rate_limit = rate_limit if rate_limit is not None else None
11467        '''
11468         Rate limit information.
11469        '''
11470
11471    def __repr__(self):
11472        return '<sdm.SecretStoreDeleteResponse ' + \
11473            'meta: ' + repr(self.meta) + ' ' +\
11474            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11475            '>'
11476
11477    def to_dict(self):
11478        return {
11479            'meta': self.meta,
11480            'rate_limit': self.rate_limit,
11481        }
11482
11483    @classmethod
11484    def from_dict(cls, d):
11485        return cls(
11486            meta=d.get('meta'),
11487            rate_limit=d.get('rate_limit'),
11488        )
11489
11490
11491class SecretStoreGetResponse:
11492    '''
11493         SecretStoreGetResponse returns a requested SecretStore.
11494    '''
11495    __slots__ = [
11496        'meta',
11497        'rate_limit',
11498        'secret_store',
11499    ]
11500
11501    def __init__(
11502        self,
11503        meta=None,
11504        rate_limit=None,
11505        secret_store=None,
11506    ):
11507        self.meta = meta if meta is not None else None
11508        '''
11509         Reserved for future use.
11510        '''
11511        self.rate_limit = rate_limit if rate_limit is not None else None
11512        '''
11513         Rate limit information.
11514        '''
11515        self.secret_store = secret_store if secret_store is not None else None
11516        '''
11517         The requested SecretStore.
11518        '''
11519
11520    def __repr__(self):
11521        return '<sdm.SecretStoreGetResponse ' + \
11522            'meta: ' + repr(self.meta) + ' ' +\
11523            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11524            'secret_store: ' + repr(self.secret_store) + ' ' +\
11525            '>'
11526
11527    def to_dict(self):
11528        return {
11529            'meta': self.meta,
11530            'rate_limit': self.rate_limit,
11531            'secret_store': self.secret_store,
11532        }
11533
11534    @classmethod
11535    def from_dict(cls, d):
11536        return cls(
11537            meta=d.get('meta'),
11538            rate_limit=d.get('rate_limit'),
11539            secret_store=d.get('secret_store'),
11540        )
11541
11542
11543class SecretStoreUpdateResponse:
11544    '''
11545         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11546     a SecretStoreUpdateRequest.
11547    '''
11548    __slots__ = [
11549        'meta',
11550        'rate_limit',
11551        'secret_store',
11552    ]
11553
11554    def __init__(
11555        self,
11556        meta=None,
11557        rate_limit=None,
11558        secret_store=None,
11559    ):
11560        self.meta = meta if meta is not None else None
11561        '''
11562         Reserved for future use.
11563        '''
11564        self.rate_limit = rate_limit if rate_limit is not None else None
11565        '''
11566         Rate limit information.
11567        '''
11568        self.secret_store = secret_store if secret_store is not None else None
11569        '''
11570         The updated SecretStore.
11571        '''
11572
11573    def __repr__(self):
11574        return '<sdm.SecretStoreUpdateResponse ' + \
11575            'meta: ' + repr(self.meta) + ' ' +\
11576            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11577            'secret_store: ' + repr(self.secret_store) + ' ' +\
11578            '>'
11579
11580    def to_dict(self):
11581        return {
11582            'meta': self.meta,
11583            'rate_limit': self.rate_limit,
11584            'secret_store': self.secret_store,
11585        }
11586
11587    @classmethod
11588    def from_dict(cls, d):
11589        return cls(
11590            meta=d.get('meta'),
11591            rate_limit=d.get('rate_limit'),
11592            secret_store=d.get('secret_store'),
11593        )
11594
11595
11596class Service:
11597    '''
11598         A Service is a service account that can connect to resources they are granted
11599     directly, or granted via roles. Services are typically automated jobs.
11600    '''
11601    __slots__ = [
11602        'id',
11603        'name',
11604        'suspended',
11605        'tags',
11606    ]
11607
11608    def __init__(
11609        self,
11610        id=None,
11611        name=None,
11612        suspended=None,
11613        tags=None,
11614    ):
11615        self.id = id if id is not None else ''
11616        '''
11617         Unique identifier of the Service.
11618        '''
11619        self.name = name if name is not None else ''
11620        '''
11621         Unique human-readable name of the Service.
11622        '''
11623        self.suspended = suspended if suspended is not None else False
11624        '''
11625         The Service's suspended state.
11626        '''
11627        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11628        '''
11629         Tags is a map of key, value pairs.
11630        '''
11631
11632    def __repr__(self):
11633        return '<sdm.Service ' + \
11634            'id: ' + repr(self.id) + ' ' +\
11635            'name: ' + repr(self.name) + ' ' +\
11636            'suspended: ' + repr(self.suspended) + ' ' +\
11637            'tags: ' + repr(self.tags) + ' ' +\
11638            '>'
11639
11640    def to_dict(self):
11641        return {
11642            'id': self.id,
11643            'name': self.name,
11644            'suspended': self.suspended,
11645            'tags': self.tags,
11646        }
11647
11648    @classmethod
11649    def from_dict(cls, d):
11650        return cls(
11651            id=d.get('id'),
11652            name=d.get('name'),
11653            suspended=d.get('suspended'),
11654            tags=d.get('tags'),
11655        )
11656
11657
11658class SingleStore:
11659    __slots__ = [
11660        'bind_interface',
11661        'database',
11662        'egress_filter',
11663        'healthy',
11664        'hostname',
11665        'id',
11666        'name',
11667        'password',
11668        'port',
11669        'port_override',
11670        'secret_store_id',
11671        'tags',
11672        'username',
11673    ]
11674
11675    def __init__(
11676        self,
11677        bind_interface=None,
11678        database=None,
11679        egress_filter=None,
11680        healthy=None,
11681        hostname=None,
11682        id=None,
11683        name=None,
11684        password=None,
11685        port=None,
11686        port_override=None,
11687        secret_store_id=None,
11688        tags=None,
11689        username=None,
11690    ):
11691        self.bind_interface = bind_interface if bind_interface is not None else ''
11692        '''
11693         Bind interface
11694        '''
11695        self.database = database if database is not None else ''
11696        self.egress_filter = egress_filter if egress_filter is not None else ''
11697        '''
11698         A filter applied to the routing logic to pin datasource to nodes.
11699        '''
11700        self.healthy = healthy if healthy is not None else False
11701        '''
11702         True if the datasource is reachable and the credentials are valid.
11703        '''
11704        self.hostname = hostname if hostname is not None else ''
11705        self.id = id if id is not None else ''
11706        '''
11707         Unique identifier of the Resource.
11708        '''
11709        self.name = name if name is not None else ''
11710        '''
11711         Unique human-readable name of the Resource.
11712        '''
11713        self.password = password if password is not None else ''
11714        self.port = port if port is not None else 0
11715        self.port_override = port_override if port_override is not None else 0
11716        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11717        '''
11718         ID of the secret store containing credentials for this resource, if any.
11719        '''
11720        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11721        '''
11722         Tags is a map of key, value pairs.
11723        '''
11724        self.username = username if username is not None else ''
11725
11726    def __repr__(self):
11727        return '<sdm.SingleStore ' + \
11728            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11729            'database: ' + repr(self.database) + ' ' +\
11730            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11731            'healthy: ' + repr(self.healthy) + ' ' +\
11732            'hostname: ' + repr(self.hostname) + ' ' +\
11733            'id: ' + repr(self.id) + ' ' +\
11734            'name: ' + repr(self.name) + ' ' +\
11735            'password: ' + repr(self.password) + ' ' +\
11736            'port: ' + repr(self.port) + ' ' +\
11737            'port_override: ' + repr(self.port_override) + ' ' +\
11738            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11739            'tags: ' + repr(self.tags) + ' ' +\
11740            'username: ' + repr(self.username) + ' ' +\
11741            '>'
11742
11743    def to_dict(self):
11744        return {
11745            'bind_interface': self.bind_interface,
11746            'database': self.database,
11747            'egress_filter': self.egress_filter,
11748            'healthy': self.healthy,
11749            'hostname': self.hostname,
11750            'id': self.id,
11751            'name': self.name,
11752            'password': self.password,
11753            'port': self.port,
11754            'port_override': self.port_override,
11755            'secret_store_id': self.secret_store_id,
11756            'tags': self.tags,
11757            'username': self.username,
11758        }
11759
11760    @classmethod
11761    def from_dict(cls, d):
11762        return cls(
11763            bind_interface=d.get('bind_interface'),
11764            database=d.get('database'),
11765            egress_filter=d.get('egress_filter'),
11766            healthy=d.get('healthy'),
11767            hostname=d.get('hostname'),
11768            id=d.get('id'),
11769            name=d.get('name'),
11770            password=d.get('password'),
11771            port=d.get('port'),
11772            port_override=d.get('port_override'),
11773            secret_store_id=d.get('secret_store_id'),
11774            tags=d.get('tags'),
11775            username=d.get('username'),
11776        )
11777
11778
11779class Snowflake:
11780    __slots__ = [
11781        'bind_interface',
11782        'database',
11783        'egress_filter',
11784        'healthy',
11785        'hostname',
11786        'id',
11787        'name',
11788        'password',
11789        'port_override',
11790        'schema',
11791        'secret_store_id',
11792        'tags',
11793        'username',
11794    ]
11795
11796    def __init__(
11797        self,
11798        bind_interface=None,
11799        database=None,
11800        egress_filter=None,
11801        healthy=None,
11802        hostname=None,
11803        id=None,
11804        name=None,
11805        password=None,
11806        port_override=None,
11807        schema=None,
11808        secret_store_id=None,
11809        tags=None,
11810        username=None,
11811    ):
11812        self.bind_interface = bind_interface if bind_interface is not None else ''
11813        '''
11814         Bind interface
11815        '''
11816        self.database = database if database is not None else ''
11817        self.egress_filter = egress_filter if egress_filter is not None else ''
11818        '''
11819         A filter applied to the routing logic to pin datasource to nodes.
11820        '''
11821        self.healthy = healthy if healthy is not None else False
11822        '''
11823         True if the datasource is reachable and the credentials are valid.
11824        '''
11825        self.hostname = hostname if hostname is not None else ''
11826        self.id = id if id is not None else ''
11827        '''
11828         Unique identifier of the Resource.
11829        '''
11830        self.name = name if name is not None else ''
11831        '''
11832         Unique human-readable name of the Resource.
11833        '''
11834        self.password = password if password is not None else ''
11835        self.port_override = port_override if port_override is not None else 0
11836        self.schema = schema if schema is not None else ''
11837        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11838        '''
11839         ID of the secret store containing credentials for this resource, if any.
11840        '''
11841        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11842        '''
11843         Tags is a map of key, value pairs.
11844        '''
11845        self.username = username if username is not None else ''
11846
11847    def __repr__(self):
11848        return '<sdm.Snowflake ' + \
11849            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11850            'database: ' + repr(self.database) + ' ' +\
11851            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11852            'healthy: ' + repr(self.healthy) + ' ' +\
11853            'hostname: ' + repr(self.hostname) + ' ' +\
11854            'id: ' + repr(self.id) + ' ' +\
11855            'name: ' + repr(self.name) + ' ' +\
11856            'password: ' + repr(self.password) + ' ' +\
11857            'port_override: ' + repr(self.port_override) + ' ' +\
11858            'schema: ' + repr(self.schema) + ' ' +\
11859            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11860            'tags: ' + repr(self.tags) + ' ' +\
11861            'username: ' + repr(self.username) + ' ' +\
11862            '>'
11863
11864    def to_dict(self):
11865        return {
11866            'bind_interface': self.bind_interface,
11867            'database': self.database,
11868            'egress_filter': self.egress_filter,
11869            'healthy': self.healthy,
11870            'hostname': self.hostname,
11871            'id': self.id,
11872            'name': self.name,
11873            'password': self.password,
11874            'port_override': self.port_override,
11875            'schema': self.schema,
11876            'secret_store_id': self.secret_store_id,
11877            'tags': self.tags,
11878            'username': self.username,
11879        }
11880
11881    @classmethod
11882    def from_dict(cls, d):
11883        return cls(
11884            bind_interface=d.get('bind_interface'),
11885            database=d.get('database'),
11886            egress_filter=d.get('egress_filter'),
11887            healthy=d.get('healthy'),
11888            hostname=d.get('hostname'),
11889            id=d.get('id'),
11890            name=d.get('name'),
11891            password=d.get('password'),
11892            port_override=d.get('port_override'),
11893            schema=d.get('schema'),
11894            secret_store_id=d.get('secret_store_id'),
11895            tags=d.get('tags'),
11896            username=d.get('username'),
11897        )
11898
11899
11900class Snowsight:
11901    '''
11902    Snowsight is currently unstable, and its API may change, or it may be removed,
11903    without a major version bump.
11904    '''
11905    __slots__ = [
11906        'bind_interface',
11907        'egress_filter',
11908        'healthcheck_username',
11909        'healthy',
11910        'id',
11911        'name',
11912        'port_override',
11913        'samlmetadata',
11914        'secret_store_id',
11915        'subdomain',
11916        'tags',
11917    ]
11918
11919    def __init__(
11920        self,
11921        bind_interface=None,
11922        egress_filter=None,
11923        healthcheck_username=None,
11924        healthy=None,
11925        id=None,
11926        name=None,
11927        port_override=None,
11928        samlmetadata=None,
11929        secret_store_id=None,
11930        subdomain=None,
11931        tags=None,
11932    ):
11933        self.bind_interface = bind_interface if bind_interface is not None else ''
11934        '''
11935         Bind interface
11936        '''
11937        self.egress_filter = egress_filter if egress_filter is not None else ''
11938        '''
11939         A filter applied to the routing logic to pin datasource to nodes.
11940        '''
11941        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11942        self.healthy = healthy if healthy is not None else False
11943        '''
11944         True if the datasource is reachable and the credentials are valid.
11945        '''
11946        self.id = id if id is not None else ''
11947        '''
11948         Unique identifier of the Resource.
11949        '''
11950        self.name = name if name is not None else ''
11951        '''
11952         Unique human-readable name of the Resource.
11953        '''
11954        self.port_override = port_override if port_override is not None else 0
11955        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11956        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11957        '''
11958         ID of the secret store containing credentials for this resource, if any.
11959        '''
11960        self.subdomain = subdomain if subdomain is not None else ''
11961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11962        '''
11963         Tags is a map of key, value pairs.
11964        '''
11965
11966    def __repr__(self):
11967        return '<sdm.Snowsight ' + \
11968            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11969            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11970            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11971            'healthy: ' + repr(self.healthy) + ' ' +\
11972            'id: ' + repr(self.id) + ' ' +\
11973            'name: ' + repr(self.name) + ' ' +\
11974            'port_override: ' + repr(self.port_override) + ' ' +\
11975            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11976            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11977            'subdomain: ' + repr(self.subdomain) + ' ' +\
11978            'tags: ' + repr(self.tags) + ' ' +\
11979            '>'
11980
11981    def to_dict(self):
11982        return {
11983            'bind_interface': self.bind_interface,
11984            'egress_filter': self.egress_filter,
11985            'healthcheck_username': self.healthcheck_username,
11986            'healthy': self.healthy,
11987            'id': self.id,
11988            'name': self.name,
11989            'port_override': self.port_override,
11990            'samlmetadata': self.samlmetadata,
11991            'secret_store_id': self.secret_store_id,
11992            'subdomain': self.subdomain,
11993            'tags': self.tags,
11994        }
11995
11996    @classmethod
11997    def from_dict(cls, d):
11998        return cls(
11999            bind_interface=d.get('bind_interface'),
12000            egress_filter=d.get('egress_filter'),
12001            healthcheck_username=d.get('healthcheck_username'),
12002            healthy=d.get('healthy'),
12003            id=d.get('id'),
12004            name=d.get('name'),
12005            port_override=d.get('port_override'),
12006            samlmetadata=d.get('samlmetadata'),
12007            secret_store_id=d.get('secret_store_id'),
12008            subdomain=d.get('subdomain'),
12009            tags=d.get('tags'),
12010        )
12011
12012
12013class Sybase:
12014    __slots__ = [
12015        'bind_interface',
12016        'egress_filter',
12017        'healthy',
12018        'hostname',
12019        'id',
12020        'name',
12021        'password',
12022        'port',
12023        'port_override',
12024        'secret_store_id',
12025        'tags',
12026        'username',
12027    ]
12028
12029    def __init__(
12030        self,
12031        bind_interface=None,
12032        egress_filter=None,
12033        healthy=None,
12034        hostname=None,
12035        id=None,
12036        name=None,
12037        password=None,
12038        port=None,
12039        port_override=None,
12040        secret_store_id=None,
12041        tags=None,
12042        username=None,
12043    ):
12044        self.bind_interface = bind_interface if bind_interface is not None else ''
12045        '''
12046         Bind interface
12047        '''
12048        self.egress_filter = egress_filter if egress_filter is not None else ''
12049        '''
12050         A filter applied to the routing logic to pin datasource to nodes.
12051        '''
12052        self.healthy = healthy if healthy is not None else False
12053        '''
12054         True if the datasource is reachable and the credentials are valid.
12055        '''
12056        self.hostname = hostname if hostname is not None else ''
12057        self.id = id if id is not None else ''
12058        '''
12059         Unique identifier of the Resource.
12060        '''
12061        self.name = name if name is not None else ''
12062        '''
12063         Unique human-readable name of the Resource.
12064        '''
12065        self.password = password if password is not None else ''
12066        self.port = port if port is not None else 0
12067        self.port_override = port_override if port_override is not None else 0
12068        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12069        '''
12070         ID of the secret store containing credentials for this resource, if any.
12071        '''
12072        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12073        '''
12074         Tags is a map of key, value pairs.
12075        '''
12076        self.username = username if username is not None else ''
12077
12078    def __repr__(self):
12079        return '<sdm.Sybase ' + \
12080            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12081            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12082            'healthy: ' + repr(self.healthy) + ' ' +\
12083            'hostname: ' + repr(self.hostname) + ' ' +\
12084            'id: ' + repr(self.id) + ' ' +\
12085            'name: ' + repr(self.name) + ' ' +\
12086            'password: ' + repr(self.password) + ' ' +\
12087            'port: ' + repr(self.port) + ' ' +\
12088            'port_override: ' + repr(self.port_override) + ' ' +\
12089            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12090            'tags: ' + repr(self.tags) + ' ' +\
12091            'username: ' + repr(self.username) + ' ' +\
12092            '>'
12093
12094    def to_dict(self):
12095        return {
12096            'bind_interface': self.bind_interface,
12097            'egress_filter': self.egress_filter,
12098            'healthy': self.healthy,
12099            'hostname': self.hostname,
12100            'id': self.id,
12101            'name': self.name,
12102            'password': self.password,
12103            'port': self.port,
12104            'port_override': self.port_override,
12105            'secret_store_id': self.secret_store_id,
12106            'tags': self.tags,
12107            'username': self.username,
12108        }
12109
12110    @classmethod
12111    def from_dict(cls, d):
12112        return cls(
12113            bind_interface=d.get('bind_interface'),
12114            egress_filter=d.get('egress_filter'),
12115            healthy=d.get('healthy'),
12116            hostname=d.get('hostname'),
12117            id=d.get('id'),
12118            name=d.get('name'),
12119            password=d.get('password'),
12120            port=d.get('port'),
12121            port_override=d.get('port_override'),
12122            secret_store_id=d.get('secret_store_id'),
12123            tags=d.get('tags'),
12124            username=d.get('username'),
12125        )
12126
12127
12128class SybaseIQ:
12129    __slots__ = [
12130        'bind_interface',
12131        'egress_filter',
12132        'healthy',
12133        'hostname',
12134        'id',
12135        'name',
12136        'password',
12137        'port',
12138        'port_override',
12139        'secret_store_id',
12140        'tags',
12141        'username',
12142    ]
12143
12144    def __init__(
12145        self,
12146        bind_interface=None,
12147        egress_filter=None,
12148        healthy=None,
12149        hostname=None,
12150        id=None,
12151        name=None,
12152        password=None,
12153        port=None,
12154        port_override=None,
12155        secret_store_id=None,
12156        tags=None,
12157        username=None,
12158    ):
12159        self.bind_interface = bind_interface if bind_interface is not None else ''
12160        '''
12161         Bind interface
12162        '''
12163        self.egress_filter = egress_filter if egress_filter is not None else ''
12164        '''
12165         A filter applied to the routing logic to pin datasource to nodes.
12166        '''
12167        self.healthy = healthy if healthy is not None else False
12168        '''
12169         True if the datasource is reachable and the credentials are valid.
12170        '''
12171        self.hostname = hostname if hostname is not None else ''
12172        self.id = id if id is not None else ''
12173        '''
12174         Unique identifier of the Resource.
12175        '''
12176        self.name = name if name is not None else ''
12177        '''
12178         Unique human-readable name of the Resource.
12179        '''
12180        self.password = password if password is not None else ''
12181        self.port = port if port is not None else 0
12182        self.port_override = port_override if port_override is not None else 0
12183        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12184        '''
12185         ID of the secret store containing credentials for this resource, if any.
12186        '''
12187        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12188        '''
12189         Tags is a map of key, value pairs.
12190        '''
12191        self.username = username if username is not None else ''
12192
12193    def __repr__(self):
12194        return '<sdm.SybaseIQ ' + \
12195            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12196            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12197            'healthy: ' + repr(self.healthy) + ' ' +\
12198            'hostname: ' + repr(self.hostname) + ' ' +\
12199            'id: ' + repr(self.id) + ' ' +\
12200            'name: ' + repr(self.name) + ' ' +\
12201            'password: ' + repr(self.password) + ' ' +\
12202            'port: ' + repr(self.port) + ' ' +\
12203            'port_override: ' + repr(self.port_override) + ' ' +\
12204            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12205            'tags: ' + repr(self.tags) + ' ' +\
12206            'username: ' + repr(self.username) + ' ' +\
12207            '>'
12208
12209    def to_dict(self):
12210        return {
12211            'bind_interface': self.bind_interface,
12212            'egress_filter': self.egress_filter,
12213            'healthy': self.healthy,
12214            'hostname': self.hostname,
12215            'id': self.id,
12216            'name': self.name,
12217            'password': self.password,
12218            'port': self.port,
12219            'port_override': self.port_override,
12220            'secret_store_id': self.secret_store_id,
12221            'tags': self.tags,
12222            'username': self.username,
12223        }
12224
12225    @classmethod
12226    def from_dict(cls, d):
12227        return cls(
12228            bind_interface=d.get('bind_interface'),
12229            egress_filter=d.get('egress_filter'),
12230            healthy=d.get('healthy'),
12231            hostname=d.get('hostname'),
12232            id=d.get('id'),
12233            name=d.get('name'),
12234            password=d.get('password'),
12235            port=d.get('port'),
12236            port_override=d.get('port_override'),
12237            secret_store_id=d.get('secret_store_id'),
12238            tags=d.get('tags'),
12239            username=d.get('username'),
12240        )
12241
12242
12243class Tag:
12244    __slots__ = [
12245        'name',
12246        'value',
12247    ]
12248
12249    def __init__(
12250        self,
12251        name=None,
12252        value=None,
12253    ):
12254        self.name = name if name is not None else ''
12255        self.value = value if value is not None else ''
12256
12257    def __repr__(self):
12258        return '<sdm.Tag ' + \
12259            'name: ' + repr(self.name) + ' ' +\
12260            'value: ' + repr(self.value) + ' ' +\
12261            '>'
12262
12263    def to_dict(self):
12264        return {
12265            'name': self.name,
12266            'value': self.value,
12267        }
12268
12269    @classmethod
12270    def from_dict(cls, d):
12271        return cls(
12272            name=d.get('name'),
12273            value=d.get('value'),
12274        )
12275
12276
12277class Teradata:
12278    __slots__ = [
12279        'bind_interface',
12280        'egress_filter',
12281        'healthy',
12282        'hostname',
12283        'id',
12284        'name',
12285        'password',
12286        'port',
12287        'port_override',
12288        'secret_store_id',
12289        'tags',
12290        'username',
12291    ]
12292
12293    def __init__(
12294        self,
12295        bind_interface=None,
12296        egress_filter=None,
12297        healthy=None,
12298        hostname=None,
12299        id=None,
12300        name=None,
12301        password=None,
12302        port=None,
12303        port_override=None,
12304        secret_store_id=None,
12305        tags=None,
12306        username=None,
12307    ):
12308        self.bind_interface = bind_interface if bind_interface is not None else ''
12309        '''
12310         Bind interface
12311        '''
12312        self.egress_filter = egress_filter if egress_filter is not None else ''
12313        '''
12314         A filter applied to the routing logic to pin datasource to nodes.
12315        '''
12316        self.healthy = healthy if healthy is not None else False
12317        '''
12318         True if the datasource is reachable and the credentials are valid.
12319        '''
12320        self.hostname = hostname if hostname is not None else ''
12321        self.id = id if id is not None else ''
12322        '''
12323         Unique identifier of the Resource.
12324        '''
12325        self.name = name if name is not None else ''
12326        '''
12327         Unique human-readable name of the Resource.
12328        '''
12329        self.password = password if password is not None else ''
12330        self.port = port if port is not None else 0
12331        self.port_override = port_override if port_override is not None else 0
12332        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12333        '''
12334         ID of the secret store containing credentials for this resource, if any.
12335        '''
12336        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12337        '''
12338         Tags is a map of key, value pairs.
12339        '''
12340        self.username = username if username is not None else ''
12341
12342    def __repr__(self):
12343        return '<sdm.Teradata ' + \
12344            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12345            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12346            'healthy: ' + repr(self.healthy) + ' ' +\
12347            'hostname: ' + repr(self.hostname) + ' ' +\
12348            'id: ' + repr(self.id) + ' ' +\
12349            'name: ' + repr(self.name) + ' ' +\
12350            'password: ' + repr(self.password) + ' ' +\
12351            'port: ' + repr(self.port) + ' ' +\
12352            'port_override: ' + repr(self.port_override) + ' ' +\
12353            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12354            'tags: ' + repr(self.tags) + ' ' +\
12355            'username: ' + repr(self.username) + ' ' +\
12356            '>'
12357
12358    def to_dict(self):
12359        return {
12360            'bind_interface': self.bind_interface,
12361            'egress_filter': self.egress_filter,
12362            'healthy': self.healthy,
12363            'hostname': self.hostname,
12364            'id': self.id,
12365            'name': self.name,
12366            'password': self.password,
12367            'port': self.port,
12368            'port_override': self.port_override,
12369            'secret_store_id': self.secret_store_id,
12370            'tags': self.tags,
12371            'username': self.username,
12372        }
12373
12374    @classmethod
12375    def from_dict(cls, d):
12376        return cls(
12377            bind_interface=d.get('bind_interface'),
12378            egress_filter=d.get('egress_filter'),
12379            healthy=d.get('healthy'),
12380            hostname=d.get('hostname'),
12381            id=d.get('id'),
12382            name=d.get('name'),
12383            password=d.get('password'),
12384            port=d.get('port'),
12385            port_override=d.get('port_override'),
12386            secret_store_id=d.get('secret_store_id'),
12387            tags=d.get('tags'),
12388            username=d.get('username'),
12389        )
12390
12391
12392class UpdateResponseMetadata:
12393    '''
12394         UpdateResponseMetadata is reserved for future use.
12395    '''
12396    __slots__ = []
12397
12398    def __init__(self, ):
12399        pass
12400
12401    def __repr__(self):
12402        return '<sdm.UpdateResponseMetadata ' + \
12403            '>'
12404
12405    def to_dict(self):
12406        return {}
12407
12408    @classmethod
12409    def from_dict(cls, d):
12410        return cls()
12411
12412
12413class User:
12414    '''
12415         A User can connect to resources they are granted directly, or granted
12416     via roles.
12417    '''
12418    __slots__ = [
12419        'email',
12420        'external_id',
12421        'first_name',
12422        'id',
12423        'last_name',
12424        'managed_by',
12425        'permission_level',
12426        'suspended',
12427        'tags',
12428    ]
12429
12430    def __init__(
12431        self,
12432        email=None,
12433        external_id=None,
12434        first_name=None,
12435        id=None,
12436        last_name=None,
12437        managed_by=None,
12438        permission_level=None,
12439        suspended=None,
12440        tags=None,
12441    ):
12442        self.email = email if email is not None else ''
12443        '''
12444         The User's email address. Must be unique.
12445        '''
12446        self.external_id = external_id if external_id is not None else ''
12447        '''
12448         External ID is an alternative unique ID this user is represented by within an external service.
12449        '''
12450        self.first_name = first_name if first_name is not None else ''
12451        '''
12452         The User's first name.
12453        '''
12454        self.id = id if id is not None else ''
12455        '''
12456         Unique identifier of the User.
12457        '''
12458        self.last_name = last_name if last_name is not None else ''
12459        '''
12460         The User's last name.
12461        '''
12462        self.managed_by = managed_by if managed_by is not None else ''
12463        '''
12464         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12465        '''
12466        self.permission_level = permission_level if permission_level is not None else ''
12467        '''
12468         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12469        '''
12470        self.suspended = suspended if suspended is not None else False
12471        '''
12472         The User's suspended state.
12473        '''
12474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12475        '''
12476         Tags is a map of key, value pairs.
12477        '''
12478
12479    def __repr__(self):
12480        return '<sdm.User ' + \
12481            'email: ' + repr(self.email) + ' ' +\
12482            'external_id: ' + repr(self.external_id) + ' ' +\
12483            'first_name: ' + repr(self.first_name) + ' ' +\
12484            'id: ' + repr(self.id) + ' ' +\
12485            'last_name: ' + repr(self.last_name) + ' ' +\
12486            'managed_by: ' + repr(self.managed_by) + ' ' +\
12487            'permission_level: ' + repr(self.permission_level) + ' ' +\
12488            'suspended: ' + repr(self.suspended) + ' ' +\
12489            'tags: ' + repr(self.tags) + ' ' +\
12490            '>'
12491
12492    def to_dict(self):
12493        return {
12494            'email': self.email,
12495            'external_id': self.external_id,
12496            'first_name': self.first_name,
12497            'id': self.id,
12498            'last_name': self.last_name,
12499            'managed_by': self.managed_by,
12500            'permission_level': self.permission_level,
12501            'suspended': self.suspended,
12502            'tags': self.tags,
12503        }
12504
12505    @classmethod
12506    def from_dict(cls, d):
12507        return cls(
12508            email=d.get('email'),
12509            external_id=d.get('external_id'),
12510            first_name=d.get('first_name'),
12511            id=d.get('id'),
12512            last_name=d.get('last_name'),
12513            managed_by=d.get('managed_by'),
12514            permission_level=d.get('permission_level'),
12515            suspended=d.get('suspended'),
12516            tags=d.get('tags'),
12517        )
12518
12519
12520class VaultAppRoleStore:
12521    __slots__ = [
12522        'id',
12523        'name',
12524        'namespace',
12525        'server_address',
12526        'tags',
12527    ]
12528
12529    def __init__(
12530        self,
12531        id=None,
12532        name=None,
12533        namespace=None,
12534        server_address=None,
12535        tags=None,
12536    ):
12537        self.id = id if id is not None else ''
12538        '''
12539         Unique identifier of the SecretStore.
12540        '''
12541        self.name = name if name is not None else ''
12542        '''
12543         Unique human-readable name of the SecretStore.
12544        '''
12545        self.namespace = namespace if namespace is not None else ''
12546        self.server_address = server_address if server_address is not None else ''
12547        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12548        '''
12549         Tags is a map of key, value pairs.
12550        '''
12551
12552    def __repr__(self):
12553        return '<sdm.VaultAppRoleStore ' + \
12554            'id: ' + repr(self.id) + ' ' +\
12555            'name: ' + repr(self.name) + ' ' +\
12556            'namespace: ' + repr(self.namespace) + ' ' +\
12557            'server_address: ' + repr(self.server_address) + ' ' +\
12558            'tags: ' + repr(self.tags) + ' ' +\
12559            '>'
12560
12561    def to_dict(self):
12562        return {
12563            'id': self.id,
12564            'name': self.name,
12565            'namespace': self.namespace,
12566            'server_address': self.server_address,
12567            'tags': self.tags,
12568        }
12569
12570    @classmethod
12571    def from_dict(cls, d):
12572        return cls(
12573            id=d.get('id'),
12574            name=d.get('name'),
12575            namespace=d.get('namespace'),
12576            server_address=d.get('server_address'),
12577            tags=d.get('tags'),
12578        )
12579
12580
12581class VaultTLSStore:
12582    __slots__ = [
12583        'ca_cert_path',
12584        'client_cert_path',
12585        'client_key_path',
12586        'id',
12587        'name',
12588        'namespace',
12589        'server_address',
12590        'tags',
12591    ]
12592
12593    def __init__(
12594        self,
12595        ca_cert_path=None,
12596        client_cert_path=None,
12597        client_key_path=None,
12598        id=None,
12599        name=None,
12600        namespace=None,
12601        server_address=None,
12602        tags=None,
12603    ):
12604        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12605        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12606        self.client_key_path = client_key_path if client_key_path is not None else ''
12607        self.id = id if id is not None else ''
12608        '''
12609         Unique identifier of the SecretStore.
12610        '''
12611        self.name = name if name is not None else ''
12612        '''
12613         Unique human-readable name of the SecretStore.
12614        '''
12615        self.namespace = namespace if namespace is not None else ''
12616        self.server_address = server_address if server_address is not None else ''
12617        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12618        '''
12619         Tags is a map of key, value pairs.
12620        '''
12621
12622    def __repr__(self):
12623        return '<sdm.VaultTLSStore ' + \
12624            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12625            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12626            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12627            'id: ' + repr(self.id) + ' ' +\
12628            'name: ' + repr(self.name) + ' ' +\
12629            'namespace: ' + repr(self.namespace) + ' ' +\
12630            'server_address: ' + repr(self.server_address) + ' ' +\
12631            'tags: ' + repr(self.tags) + ' ' +\
12632            '>'
12633
12634    def to_dict(self):
12635        return {
12636            'ca_cert_path': self.ca_cert_path,
12637            'client_cert_path': self.client_cert_path,
12638            'client_key_path': self.client_key_path,
12639            'id': self.id,
12640            'name': self.name,
12641            'namespace': self.namespace,
12642            'server_address': self.server_address,
12643            'tags': self.tags,
12644        }
12645
12646    @classmethod
12647    def from_dict(cls, d):
12648        return cls(
12649            ca_cert_path=d.get('ca_cert_path'),
12650            client_cert_path=d.get('client_cert_path'),
12651            client_key_path=d.get('client_key_path'),
12652            id=d.get('id'),
12653            name=d.get('name'),
12654            namespace=d.get('namespace'),
12655            server_address=d.get('server_address'),
12656            tags=d.get('tags'),
12657        )
12658
12659
12660class VaultTokenStore:
12661    __slots__ = [
12662        'id',
12663        'name',
12664        'namespace',
12665        'server_address',
12666        'tags',
12667    ]
12668
12669    def __init__(
12670        self,
12671        id=None,
12672        name=None,
12673        namespace=None,
12674        server_address=None,
12675        tags=None,
12676    ):
12677        self.id = id if id is not None else ''
12678        '''
12679         Unique identifier of the SecretStore.
12680        '''
12681        self.name = name if name is not None else ''
12682        '''
12683         Unique human-readable name of the SecretStore.
12684        '''
12685        self.namespace = namespace if namespace is not None else ''
12686        self.server_address = server_address if server_address is not None else ''
12687        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12688        '''
12689         Tags is a map of key, value pairs.
12690        '''
12691
12692    def __repr__(self):
12693        return '<sdm.VaultTokenStore ' + \
12694            'id: ' + repr(self.id) + ' ' +\
12695            'name: ' + repr(self.name) + ' ' +\
12696            'namespace: ' + repr(self.namespace) + ' ' +\
12697            'server_address: ' + repr(self.server_address) + ' ' +\
12698            'tags: ' + repr(self.tags) + ' ' +\
12699            '>'
12700
12701    def to_dict(self):
12702        return {
12703            'id': self.id,
12704            'name': self.name,
12705            'namespace': self.namespace,
12706            'server_address': self.server_address,
12707            'tags': self.tags,
12708        }
12709
12710    @classmethod
12711    def from_dict(cls, d):
12712        return cls(
12713            id=d.get('id'),
12714            name=d.get('name'),
12715            namespace=d.get('namespace'),
12716            server_address=d.get('server_address'),
12717            tags=d.get('tags'),
12718        )
12719
12720
12721def _porcelain_zero_value_tags():
12722    return {}
12723
12724
12725def _porcelain_zero_value_access_rules():
12726    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSConsole:
785class AWSConsole:
786    '''
787    AWSConsole is currently unstable, and its API may change, or it may be removed,
788    without a major version bump.
789    '''
790    __slots__ = [
791        'bind_interface',
792        'egress_filter',
793        'enable_env_variables',
794        'healthy',
795        'id',
796        'name',
797        'port_override',
798        'region',
799        'remote_identity_group_id',
800        'remote_identity_healthcheck_username',
801        'role_arn',
802        'role_external_id',
803        'secret_store_id',
804        'session_expiry',
805        'subdomain',
806        'tags',
807    ]
808
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
865
866    def __repr__(self):
867        return '<sdm.AWSConsole ' + \
868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
870            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
871            'healthy: ' + repr(self.healthy) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'name: ' + repr(self.name) + ' ' +\
874            'port_override: ' + repr(self.port_override) + ' ' +\
875            'region: ' + repr(self.region) + ' ' +\
876            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
877            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
878            'role_arn: ' + repr(self.role_arn) + ' ' +\
879            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
881            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
882            'subdomain: ' + repr(self.subdomain) + ' ' +\
883            'tags: ' + repr(self.tags) + ' ' +\
884            '>'
885
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
906
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )

AWSConsole is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsole( bind_interface=None, egress_filter=None, enable_env_variables=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

enable_env_variables
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
@classmethod
def from_dict(cls, d)
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )
class AWSConsoleStaticKeyPair:
 930class AWSConsoleStaticKeyPair:
 931    '''
 932    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
 933    without a major version bump.
 934    '''
 935    __slots__ = [
 936        'access_key',
 937        'bind_interface',
 938        'egress_filter',
 939        'healthy',
 940        'id',
 941        'name',
 942        'port_override',
 943        'region',
 944        'remote_identity_group_id',
 945        'remote_identity_healthcheck_username',
 946        'role_arn',
 947        'role_external_id',
 948        'secret_access_key',
 949        'secret_store_id',
 950        'session_expiry',
 951        'subdomain',
 952        'tags',
 953    ]
 954
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
1013
1014    def __repr__(self):
1015        return '<sdm.AWSConsoleStaticKeyPair ' + \
1016            'access_key: ' + repr(self.access_key) + ' ' +\
1017            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1019            'healthy: ' + repr(self.healthy) + ' ' +\
1020            'id: ' + repr(self.id) + ' ' +\
1021            'name: ' + repr(self.name) + ' ' +\
1022            'port_override: ' + repr(self.port_override) + ' ' +\
1023            'region: ' + repr(self.region) + ' ' +\
1024            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1025            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1026            'role_arn: ' + repr(self.role_arn) + ' ' +\
1027            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1028            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1030            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
1031            'subdomain: ' + repr(self.subdomain) + ' ' +\
1032            'tags: ' + repr(self.tags) + ' ' +\
1033            '>'
1034
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
1056
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )

AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsoleStaticKeyPair( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
@classmethod
def from_dict(cls, d)
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )
class AWSStore:
1081class AWSStore:
1082    __slots__ = [
1083        'id',
1084        'name',
1085        'region',
1086        'tags',
1087    ]
1088
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
1109
1110    def __repr__(self):
1111        return '<sdm.AWSStore ' + \
1112            'id: ' + repr(self.id) + ' ' +\
1113            'name: ' + repr(self.name) + ' ' +\
1114            'region: ' + repr(self.region) + ' ' +\
1115            'tags: ' + repr(self.tags) + ' ' +\
1116            '>'
1117
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
1125
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
AWSStore(id=None, name=None, region=None, tags=None)
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
@classmethod
def from_dict(cls, d)
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
class AccountAttachment:
1136class AccountAttachment:
1137    '''
1138         AccountAttachments assign an account to a role.
1139    '''
1140    __slots__ = [
1141        'account_id',
1142        'id',
1143        'role_id',
1144    ]
1145
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
1164
1165    def __repr__(self):
1166        return '<sdm.AccountAttachment ' + \
1167            'account_id: ' + repr(self.account_id) + ' ' +\
1168            'id: ' + repr(self.id) + ' ' +\
1169            'role_id: ' + repr(self.role_id) + ' ' +\
1170            '>'
1171
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
1178
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
@classmethod
def from_dict(cls, d)
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )
class AccountAttachmentCreateResponse:
1188class AccountAttachmentCreateResponse:
1189    '''
1190         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1191    '''
1192    __slots__ = [
1193        'account_attachment',
1194        'meta',
1195        'rate_limit',
1196    ]
1197
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
1216
1217    def __repr__(self):
1218        return '<sdm.AccountAttachmentCreateResponse ' + \
1219            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1220            'meta: ' + repr(self.meta) + ' ' +\
1221            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1222            '>'
1223
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
1230
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
@classmethod
def from_dict(cls, d)
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )
class AccountAttachmentDeleteResponse:
1240class AccountAttachmentDeleteResponse:
1241    '''
1242         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1243    '''
1244    __slots__ = [
1245        'meta',
1246        'rate_limit',
1247    ]
1248
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
1262
1263    def __repr__(self):
1264        return '<sdm.AccountAttachmentDeleteResponse ' + \
1265            'meta: ' + repr(self.meta) + ' ' +\
1266            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1267            '>'
1268
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
1274
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
@classmethod
def from_dict(cls, d)
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )
class AccountAttachmentGetResponse:
1283class AccountAttachmentGetResponse:
1284    '''
1285         AccountAttachmentGetResponse returns a requested AccountAttachment.
1286    '''
1287    __slots__ = [
1288        'account_attachment',
1289        'meta',
1290        'rate_limit',
1291    ]
1292
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
1311
1312    def __repr__(self):
1313        return '<sdm.AccountAttachmentGetResponse ' + \
1314            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1315            'meta: ' + repr(self.meta) + ' ' +\
1316            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1317            '>'
1318
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
1325
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
@classmethod
def from_dict(cls, d)
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )
class AccountCreateResponse:
1335class AccountCreateResponse:
1336    '''
1337         AccountCreateResponse reports how the Accounts were created in the system.
1338    '''
1339    __slots__ = [
1340        'account',
1341        'meta',
1342        'rate_limit',
1343        'token',
1344    ]
1345
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
1370
1371    def __repr__(self):
1372        return '<sdm.AccountCreateResponse ' + \
1373            'account: ' + repr(self.account) + ' ' +\
1374            'meta: ' + repr(self.meta) + ' ' +\
1375            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1376            'token: ' + repr(self.token) + ' ' +\
1377            '>'
1378
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
1386
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
@classmethod
def from_dict(cls, d)
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )
class AccountDeleteResponse:
1397class AccountDeleteResponse:
1398    '''
1399         AccountDeleteResponse returns information about a Account that was deleted.
1400    '''
1401    __slots__ = [
1402        'meta',
1403        'rate_limit',
1404    ]
1405
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
1419
1420    def __repr__(self):
1421        return '<sdm.AccountDeleteResponse ' + \
1422            'meta: ' + repr(self.meta) + ' ' +\
1423            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1424            '>'
1425
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
1431
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
@classmethod
def from_dict(cls, d)
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )
class AccountGetResponse:
1440class AccountGetResponse:
1441    '''
1442         AccountGetResponse returns a requested Account.
1443    '''
1444    __slots__ = [
1445        'account',
1446        'meta',
1447        'rate_limit',
1448    ]
1449
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGetResponse ' + \
1471            'account: ' + repr(self.account) + ' ' +\
1472            'meta: ' + repr(self.meta) + ' ' +\
1473            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1474            '>'
1475
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
1482
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
@classmethod
def from_dict(cls, d)
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )
class AccountGrant:
1492class AccountGrant:
1493    '''
1494         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1495    '''
1496    __slots__ = [
1497        'account_id',
1498        'id',
1499        'resource_id',
1500        'start_from',
1501        'valid_until',
1502    ]
1503
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
1532
1533    def __repr__(self):
1534        return '<sdm.AccountGrant ' + \
1535            'account_id: ' + repr(self.account_id) + ' ' +\
1536            'id: ' + repr(self.id) + ' ' +\
1537            'resource_id: ' + repr(self.resource_id) + ' ' +\
1538            'start_from: ' + repr(self.start_from) + ' ' +\
1539            'valid_until: ' + repr(self.valid_until) + ' ' +\
1540            '>'
1541
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
1550
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
@classmethod
def from_dict(cls, d)
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )
class AccountGrantCreateResponse:
1562class AccountGrantCreateResponse:
1563    '''
1564         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1565    '''
1566    __slots__ = [
1567        'account_grant',
1568        'meta',
1569        'rate_limit',
1570    ]
1571
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
1590
1591    def __repr__(self):
1592        return '<sdm.AccountGrantCreateResponse ' + \
1593            'account_grant: ' + repr(self.account_grant) + ' ' +\
1594            'meta: ' + repr(self.meta) + ' ' +\
1595            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1596            '>'
1597
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
1604
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
@classmethod
def from_dict(cls, d)
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )
class AccountGrantDeleteResponse:
1614class AccountGrantDeleteResponse:
1615    '''
1616         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1617    '''
1618    __slots__ = [
1619        'meta',
1620        'rate_limit',
1621    ]
1622
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
1636
1637    def __repr__(self):
1638        return '<sdm.AccountGrantDeleteResponse ' + \
1639            'meta: ' + repr(self.meta) + ' ' +\
1640            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1641            '>'
1642
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
1648
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
@classmethod
def from_dict(cls, d)
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )
class AccountGrantGetResponse:
1657class AccountGrantGetResponse:
1658    '''
1659         AccountGrantGetResponse returns a requested AccountGrant.
1660    '''
1661    __slots__ = [
1662        'account_grant',
1663        'meta',
1664        'rate_limit',
1665    ]
1666
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
1685
1686    def __repr__(self):
1687        return '<sdm.AccountGrantGetResponse ' + \
1688            'account_grant: ' + repr(self.account_grant) + ' ' +\
1689            'meta: ' + repr(self.meta) + ' ' +\
1690            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1691            '>'
1692
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
1699
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
@classmethod
def from_dict(cls, d)
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )
class AccountUpdateResponse:
1709class AccountUpdateResponse:
1710    '''
1711         AccountUpdateResponse returns the fields of a Account after it has been updated by
1712     a AccountUpdateRequest.
1713    '''
1714    __slots__ = [
1715        'account',
1716        'meta',
1717        'rate_limit',
1718    ]
1719
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
1738
1739    def __repr__(self):
1740        return '<sdm.AccountUpdateResponse ' + \
1741            'account: ' + repr(self.account) + ' ' +\
1742            'meta: ' + repr(self.meta) + ' ' +\
1743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1744            '>'
1745
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
1752
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
@classmethod
def from_dict(cls, d)
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )
class AmazonEKS:
1762class AmazonEKS:
1763    __slots__ = [
1764        'access_key',
1765        'bind_interface',
1766        'certificate_authority',
1767        'cluster_name',
1768        'egress_filter',
1769        'endpoint',
1770        'healthcheck_namespace',
1771        'healthy',
1772        'id',
1773        'name',
1774        'region',
1775        'remote_identity_group_id',
1776        'remote_identity_healthcheck_username',
1777        'role_arn',
1778        'role_external_id',
1779        'secret_access_key',
1780        'secret_store_id',
1781        'tags',
1782    ]
1783
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
1847
1848    def __repr__(self):
1849        return '<sdm.AmazonEKS ' + \
1850            'access_key: ' + repr(self.access_key) + ' ' +\
1851            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1852            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1853            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1855            'endpoint: ' + repr(self.endpoint) + ' ' +\
1856            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1857            'healthy: ' + repr(self.healthy) + ' ' +\
1858            'id: ' + repr(self.id) + ' ' +\
1859            'name: ' + repr(self.name) + ' ' +\
1860            'region: ' + repr(self.region) + ' ' +\
1861            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1862            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1863            'role_arn: ' + repr(self.role_arn) + ' ' +\
1864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1867            'tags: ' + repr(self.tags) + ' ' +\
1868            '>'
1869
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
1892
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
@classmethod
def from_dict(cls, d)
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
class AmazonEKSInstanceProfile:
1918class AmazonEKSInstanceProfile:
1919    '''
1920    AmazonEKSInstanceProfile is currently unstable, and its API may change, or it may be removed,
1921    without a major version bump.
1922    '''
1923    __slots__ = [
1924        'bind_interface',
1925        'certificate_authority',
1926        'cluster_name',
1927        'egress_filter',
1928        'endpoint',
1929        'healthcheck_namespace',
1930        'healthy',
1931        'id',
1932        'name',
1933        'region',
1934        'remote_identity_group_id',
1935        'remote_identity_healthcheck_username',
1936        'role_arn',
1937        'role_external_id',
1938        'secret_store_id',
1939        'tags',
1940    ]
1941
1942    def __init__(
1943        self,
1944        bind_interface=None,
1945        certificate_authority=None,
1946        cluster_name=None,
1947        egress_filter=None,
1948        endpoint=None,
1949        healthcheck_namespace=None,
1950        healthy=None,
1951        id=None,
1952        name=None,
1953        region=None,
1954        remote_identity_group_id=None,
1955        remote_identity_healthcheck_username=None,
1956        role_arn=None,
1957        role_external_id=None,
1958        secret_store_id=None,
1959        tags=None,
1960    ):
1961        self.bind_interface = bind_interface if bind_interface is not None else ''
1962        '''
1963         Bind interface
1964        '''
1965        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1966        self.cluster_name = cluster_name if cluster_name is not None else ''
1967        self.egress_filter = egress_filter if egress_filter is not None else ''
1968        '''
1969         A filter applied to the routing logic to pin datasource to nodes.
1970        '''
1971        self.endpoint = endpoint if endpoint is not None else ''
1972        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1973        '''
1974         The path used to check the health of your connection.  Defaults to `default`.
1975        '''
1976        self.healthy = healthy if healthy is not None else False
1977        '''
1978         True if the datasource is reachable and the credentials are valid.
1979        '''
1980        self.id = id if id is not None else ''
1981        '''
1982         Unique identifier of the Resource.
1983        '''
1984        self.name = name if name is not None else ''
1985        '''
1986         Unique human-readable name of the Resource.
1987        '''
1988        self.region = region if region is not None else ''
1989        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1990        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1991        self.role_arn = role_arn if role_arn is not None else ''
1992        self.role_external_id = role_external_id if role_external_id is not None else ''
1993        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1994        '''
1995         ID of the secret store containing credentials for this resource, if any.
1996        '''
1997        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1998        '''
1999         Tags is a map of key, value pairs.
2000        '''
2001
2002    def __repr__(self):
2003        return '<sdm.AmazonEKSInstanceProfile ' + \
2004            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2005            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
2006            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
2007            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2008            'endpoint: ' + repr(self.endpoint) + ' ' +\
2009            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
2010            'healthy: ' + repr(self.healthy) + ' ' +\
2011            'id: ' + repr(self.id) + ' ' +\
2012            'name: ' + repr(self.name) + ' ' +\
2013            'region: ' + repr(self.region) + ' ' +\
2014            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
2015            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
2016            'role_arn: ' + repr(self.role_arn) + ' ' +\
2017            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2018            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2019            'tags: ' + repr(self.tags) + ' ' +\
2020            '>'
2021
2022    def to_dict(self):
2023        return {
2024            'bind_interface': self.bind_interface,
2025            'certificate_authority': self.certificate_authority,
2026            'cluster_name': self.cluster_name,
2027            'egress_filter': self.egress_filter,
2028            'endpoint': self.endpoint,
2029            'healthcheck_namespace': self.healthcheck_namespace,
2030            'healthy': self.healthy,
2031            'id': self.id,
2032            'name': self.name,
2033            'region': self.region,
2034            'remote_identity_group_id': self.remote_identity_group_id,
2035            'remote_identity_healthcheck_username':
2036            self.remote_identity_healthcheck_username,
2037            'role_arn': self.role_arn,
2038            'role_external_id': self.role_external_id,
2039            'secret_store_id': self.secret_store_id,
2040            'tags': self.tags,
2041        }
2042
2043    @classmethod
2044    def from_dict(cls, d):
2045        return cls(
2046            bind_interface=d.get('bind_interface'),
2047            certificate_authority=d.get('certificate_authority'),
2048            cluster_name=d.get('cluster_name'),
2049            egress_filter=d.get('egress_filter'),
2050            endpoint=d.get('endpoint'),
2051            healthcheck_namespace=d.get('healthcheck_namespace'),
2052            healthy=d.get('healthy'),
2053            id=d.get('id'),
2054            name=d.get('name'),
2055            region=d.get('region'),
2056            remote_identity_group_id=d.get('remote_identity_group_id'),
2057            remote_identity_healthcheck_username=d.get(
2058                'remote_identity_healthcheck_username'),
2059            role_arn=d.get('role_arn'),
2060            role_external_id=d.get('role_external_id'),
2061            secret_store_id=d.get('secret_store_id'),
2062            tags=d.get('tags'),
2063        )

AmazonEKSInstanceProfile is currently unstable, and its API may change, or it may be removed, without a major version bump.

AmazonEKSInstanceProfile( bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_store_id=None, tags=None)
1942    def __init__(
1943        self,
1944        bind_interface=None,
1945        certificate_authority=None,
1946        cluster_name=None,
1947        egress_filter=None,
1948        endpoint=None,
1949        healthcheck_namespace=None,
1950        healthy=None,
1951        id=None,
1952        name=None,
1953        region=None,
1954        remote_identity_group_id=None,
1955        remote_identity_healthcheck_username=None,
1956        role_arn=None,
1957        role_external_id=None,
1958        secret_store_id=None,
1959        tags=None,
1960    ):
1961        self.bind_interface = bind_interface if bind_interface is not None else ''
1962        '''
1963         Bind interface
1964        '''
1965        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1966        self.cluster_name = cluster_name if cluster_name is not None else ''
1967        self.egress_filter = egress_filter if egress_filter is not None else ''
1968        '''
1969         A filter applied to the routing logic to pin datasource to nodes.
1970        '''
1971        self.endpoint = endpoint if endpoint is not None else ''
1972        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1973        '''
1974         The path used to check the health of your connection.  Defaults to `default`.
1975        '''
1976        self.healthy = healthy if healthy is not None else False
1977        '''
1978         True if the datasource is reachable and the credentials are valid.
1979        '''
1980        self.id = id if id is not None else ''
1981        '''
1982         Unique identifier of the Resource.
1983        '''
1984        self.name = name if name is not None else ''
1985        '''
1986         Unique human-readable name of the Resource.
1987        '''
1988        self.region = region if region is not None else ''
1989        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1990        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1991        self.role_arn = role_arn if role_arn is not None else ''
1992        self.role_external_id = role_external_id if role_external_id is not None else ''
1993        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1994        '''
1995         ID of the secret store containing credentials for this resource, if any.
1996        '''
1997        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1998        '''
1999         Tags is a map of key, value pairs.
2000        '''
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2022    def to_dict(self):
2023        return {
2024            'bind_interface': self.bind_interface,
2025            'certificate_authority': self.certificate_authority,
2026            'cluster_name': self.cluster_name,
2027            'egress_filter': self.egress_filter,
2028            'endpoint': self.endpoint,
2029            'healthcheck_namespace': self.healthcheck_namespace,
2030            'healthy': self.healthy,
2031            'id': self.id,
2032            'name': self.name,
2033            'region': self.region,
2034            'remote_identity_group_id': self.remote_identity_group_id,
2035            'remote_identity_healthcheck_username':
2036            self.remote_identity_healthcheck_username,
2037            'role_arn': self.role_arn,
2038            'role_external_id': self.role_external_id,
2039            'secret_store_id': self.secret_store_id,
2040            'tags': self.tags,
2041        }
@classmethod
def from_dict(cls, d)
2043    @classmethod
2044    def from_dict(cls, d):
2045        return cls(
2046            bind_interface=d.get('bind_interface'),
2047            certificate_authority=d.get('certificate_authority'),
2048            cluster_name=d.get('cluster_name'),
2049            egress_filter=d.get('egress_filter'),
2050            endpoint=d.get('endpoint'),
2051            healthcheck_namespace=d.get('healthcheck_namespace'),
2052            healthy=d.get('healthy'),
2053            id=d.get('id'),
2054            name=d.get('name'),
2055            region=d.get('region'),
2056            remote_identity_group_id=d.get('remote_identity_group_id'),
2057            remote_identity_healthcheck_username=d.get(
2058                'remote_identity_healthcheck_username'),
2059            role_arn=d.get('role_arn'),
2060            role_external_id=d.get('role_external_id'),
2061            secret_store_id=d.get('secret_store_id'),
2062            tags=d.get('tags'),
2063        )
class AmazonEKSUserImpersonation:
2066class AmazonEKSUserImpersonation:
2067    __slots__ = [
2068        'access_key',
2069        'bind_interface',
2070        'certificate_authority',
2071        'cluster_name',
2072        'egress_filter',
2073        'endpoint',
2074        'healthcheck_namespace',
2075        'healthy',
2076        'id',
2077        'name',
2078        'region',
2079        'role_arn',
2080        'role_external_id',
2081        'secret_access_key',
2082        'secret_store_id',
2083        'tags',
2084    ]
2085
2086    def __init__(
2087        self,
2088        access_key=None,
2089        bind_interface=None,
2090        certificate_authority=None,
2091        cluster_name=None,
2092        egress_filter=None,
2093        endpoint=None,
2094        healthcheck_namespace=None,
2095        healthy=None,
2096        id=None,
2097        name=None,
2098        region=None,
2099        role_arn=None,
2100        role_external_id=None,
2101        secret_access_key=None,
2102        secret_store_id=None,
2103        tags=None,
2104    ):
2105        self.access_key = access_key if access_key is not None else ''
2106        self.bind_interface = bind_interface if bind_interface is not None else ''
2107        '''
2108         Bind interface
2109        '''
2110        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
2111        self.cluster_name = cluster_name if cluster_name is not None else ''
2112        self.egress_filter = egress_filter if egress_filter is not None else ''
2113        '''
2114         A filter applied to the routing logic to pin datasource to nodes.
2115        '''
2116        self.endpoint = endpoint if endpoint is not None else ''
2117        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
2118        '''
2119         The path used to check the health of your connection.  Defaults to `default`.
2120        '''
2121        self.healthy = healthy if healthy is not None else False
2122        '''
2123         True if the datasource is reachable and the credentials are valid.
2124        '''
2125        self.id = id if id is not None else ''
2126        '''
2127         Unique identifier of the Resource.
2128        '''
2129        self.name = name if name is not None else ''
2130        '''
2131         Unique human-readable name of the Resource.
2132        '''
2133        self.region = region if region is not None else ''
2134        self.role_arn = role_arn if role_arn is not None else ''
2135        self.role_external_id = role_external_id if role_external_id is not None else ''
2136        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2137        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2138        '''
2139         ID of the secret store containing credentials for this resource, if any.
2140        '''
2141        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2142        '''
2143         Tags is a map of key, value pairs.
2144        '''
2145
2146    def __repr__(self):
2147        return '<sdm.AmazonEKSUserImpersonation ' + \
2148            'access_key: ' + repr(self.access_key) + ' ' +\
2149            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2150            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
2151            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
2152            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2153            'endpoint: ' + repr(self.endpoint) + ' ' +\
2154            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
2155            'healthy: ' + repr(self.healthy) + ' ' +\
2156            'id: ' + repr(self.id) + ' ' +\
2157            'name: ' + repr(self.name) + ' ' +\
2158            'region: ' + repr(self.region) + ' ' +\
2159            'role_arn: ' + repr(self.role_arn) + ' ' +\
2160            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2161            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2162            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2163            'tags: ' + repr(self.tags) + ' ' +\
2164            '>'
2165
2166    def to_dict(self):
2167        return {
2168            'access_key': self.access_key,
2169            'bind_interface': self.bind_interface,
2170            'certificate_authority': self.certificate_authority,
2171            'cluster_name': self.cluster_name,
2172            'egress_filter': self.egress_filter,
2173            'endpoint': self.endpoint,
2174            'healthcheck_namespace': self.healthcheck_namespace,
2175            'healthy': self.healthy,
2176            'id': self.id,
2177            'name': self.name,
2178            'region': self.region,
2179            'role_arn': self.role_arn,
2180            'role_external_id': self.role_external_id,
2181            'secret_access_key': self.secret_access_key,
2182            'secret_store_id': self.secret_store_id,
2183            'tags': self.tags,
2184        }
2185
2186    @classmethod
2187    def from_dict(cls, d):
2188        return cls(
2189            access_key=d.get('access_key'),
2190            bind_interface=d.get('bind_interface'),
2191            certificate_authority=d.get('certificate_authority'),
2192            cluster_name=d.get('cluster_name'),
2193            egress_filter=d.get('egress_filter'),
2194            endpoint=d.get('endpoint'),
2195            healthcheck_namespace=d.get('healthcheck_namespace'),
2196            healthy=d.get('healthy'),
2197            id=d.get('id'),
2198            name=d.get('name'),
2199            region=d.get('region'),
2200            role_arn=d.get('role_arn'),
2201            role_external_id=d.get('role_external_id'),
2202            secret_access_key=d.get('secret_access_key'),
2203            secret_store_id=d.get('secret_store_id'),
2204            tags=d.get('tags'),
2205        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2086    def __init__(
2087        self,
2088        access_key=None,
2089        bind_interface=None,
2090        certificate_authority=None,
2091        cluster_name=None,
2092        egress_filter=None,
2093        endpoint=None,
2094        healthcheck_namespace=None,
2095        healthy=None,
2096        id=None,
2097        name=None,
2098        region=None,
2099        role_arn=None,
2100        role_external_id=None,
2101        secret_access_key=None,
2102        secret_store_id=None,
2103        tags=None,
2104    ):
2105        self.access_key = access_key if access_key is not None else ''
2106        self.bind_interface = bind_interface if bind_interface is not None else ''
2107        '''
2108         Bind interface
2109        '''
2110        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
2111        self.cluster_name = cluster_name if cluster_name is not None else ''
2112        self.egress_filter = egress_filter if egress_filter is not None else ''
2113        '''
2114         A filter applied to the routing logic to pin datasource to nodes.
2115        '''
2116        self.endpoint = endpoint if endpoint is not None else ''
2117        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
2118        '''
2119         The path used to check the health of your connection.  Defaults to `default`.
2120        '''
2121        self.healthy = healthy if healthy is not None else False
2122        '''
2123         True if the datasource is reachable and the credentials are valid.
2124        '''
2125        self.id = id if id is not None else ''
2126        '''
2127         Unique identifier of the Resource.
2128        '''
2129        self.name = name if name is not None else ''
2130        '''
2131         Unique human-readable name of the Resource.
2132        '''
2133        self.region = region if region is not None else ''
2134        self.role_arn = role_arn if role_arn is not None else ''
2135        self.role_external_id = role_external_id if role_external_id is not None else ''
2136        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2137        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2138        '''
2139         ID of the secret store containing credentials for this resource, if any.
2140        '''
2141        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2142        '''
2143         Tags is a map of key, value pairs.
2144        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2166    def to_dict(self):
2167        return {
2168            'access_key': self.access_key,
2169            'bind_interface': self.bind_interface,
2170            'certificate_authority': self.certificate_authority,
2171            'cluster_name': self.cluster_name,
2172            'egress_filter': self.egress_filter,
2173            'endpoint': self.endpoint,
2174            'healthcheck_namespace': self.healthcheck_namespace,
2175            'healthy': self.healthy,
2176            'id': self.id,
2177            'name': self.name,
2178            'region': self.region,
2179            'role_arn': self.role_arn,
2180            'role_external_id': self.role_external_id,
2181            'secret_access_key': self.secret_access_key,
2182            'secret_store_id': self.secret_store_id,
2183            'tags': self.tags,
2184        }
@classmethod
def from_dict(cls, d)
2186    @classmethod
2187    def from_dict(cls, d):
2188        return cls(
2189            access_key=d.get('access_key'),
2190            bind_interface=d.get('bind_interface'),
2191            certificate_authority=d.get('certificate_authority'),
2192            cluster_name=d.get('cluster_name'),
2193            egress_filter=d.get('egress_filter'),
2194            endpoint=d.get('endpoint'),
2195            healthcheck_namespace=d.get('healthcheck_namespace'),
2196            healthy=d.get('healthy'),
2197            id=d.get('id'),
2198            name=d.get('name'),
2199            region=d.get('region'),
2200            role_arn=d.get('role_arn'),
2201            role_external_id=d.get('role_external_id'),
2202            secret_access_key=d.get('secret_access_key'),
2203            secret_store_id=d.get('secret_store_id'),
2204            tags=d.get('tags'),
2205        )
class AmazonES:
2208class AmazonES:
2209    __slots__ = [
2210        'access_key',
2211        'bind_interface',
2212        'egress_filter',
2213        'endpoint',
2214        'healthy',
2215        'id',
2216        'name',
2217        'port_override',
2218        'region',
2219        'role_arn',
2220        'role_external_id',
2221        'secret_access_key',
2222        'secret_store_id',
2223        'tags',
2224    ]
2225
2226    def __init__(
2227        self,
2228        access_key=None,
2229        bind_interface=None,
2230        egress_filter=None,
2231        endpoint=None,
2232        healthy=None,
2233        id=None,
2234        name=None,
2235        port_override=None,
2236        region=None,
2237        role_arn=None,
2238        role_external_id=None,
2239        secret_access_key=None,
2240        secret_store_id=None,
2241        tags=None,
2242    ):
2243        self.access_key = access_key if access_key is not None else ''
2244        self.bind_interface = bind_interface if bind_interface is not None else ''
2245        '''
2246         Bind interface
2247        '''
2248        self.egress_filter = egress_filter if egress_filter is not None else ''
2249        '''
2250         A filter applied to the routing logic to pin datasource to nodes.
2251        '''
2252        self.endpoint = endpoint if endpoint is not None else ''
2253        self.healthy = healthy if healthy is not None else False
2254        '''
2255         True if the datasource is reachable and the credentials are valid.
2256        '''
2257        self.id = id if id is not None else ''
2258        '''
2259         Unique identifier of the Resource.
2260        '''
2261        self.name = name if name is not None else ''
2262        '''
2263         Unique human-readable name of the Resource.
2264        '''
2265        self.port_override = port_override if port_override is not None else 0
2266        self.region = region if region is not None else ''
2267        self.role_arn = role_arn if role_arn is not None else ''
2268        self.role_external_id = role_external_id if role_external_id is not None else ''
2269        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2270        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2271        '''
2272         ID of the secret store containing credentials for this resource, if any.
2273        '''
2274        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2275        '''
2276         Tags is a map of key, value pairs.
2277        '''
2278
2279    def __repr__(self):
2280        return '<sdm.AmazonES ' + \
2281            'access_key: ' + repr(self.access_key) + ' ' +\
2282            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2283            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2284            'endpoint: ' + repr(self.endpoint) + ' ' +\
2285            'healthy: ' + repr(self.healthy) + ' ' +\
2286            'id: ' + repr(self.id) + ' ' +\
2287            'name: ' + repr(self.name) + ' ' +\
2288            'port_override: ' + repr(self.port_override) + ' ' +\
2289            'region: ' + repr(self.region) + ' ' +\
2290            'role_arn: ' + repr(self.role_arn) + ' ' +\
2291            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2292            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2293            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2294            'tags: ' + repr(self.tags) + ' ' +\
2295            '>'
2296
2297    def to_dict(self):
2298        return {
2299            'access_key': self.access_key,
2300            'bind_interface': self.bind_interface,
2301            'egress_filter': self.egress_filter,
2302            'endpoint': self.endpoint,
2303            'healthy': self.healthy,
2304            'id': self.id,
2305            'name': self.name,
2306            'port_override': self.port_override,
2307            'region': self.region,
2308            'role_arn': self.role_arn,
2309            'role_external_id': self.role_external_id,
2310            'secret_access_key': self.secret_access_key,
2311            'secret_store_id': self.secret_store_id,
2312            'tags': self.tags,
2313        }
2314
2315    @classmethod
2316    def from_dict(cls, d):
2317        return cls(
2318            access_key=d.get('access_key'),
2319            bind_interface=d.get('bind_interface'),
2320            egress_filter=d.get('egress_filter'),
2321            endpoint=d.get('endpoint'),
2322            healthy=d.get('healthy'),
2323            id=d.get('id'),
2324            name=d.get('name'),
2325            port_override=d.get('port_override'),
2326            region=d.get('region'),
2327            role_arn=d.get('role_arn'),
2328            role_external_id=d.get('role_external_id'),
2329            secret_access_key=d.get('secret_access_key'),
2330            secret_store_id=d.get('secret_store_id'),
2331            tags=d.get('tags'),
2332        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2226    def __init__(
2227        self,
2228        access_key=None,
2229        bind_interface=None,
2230        egress_filter=None,
2231        endpoint=None,
2232        healthy=None,
2233        id=None,
2234        name=None,
2235        port_override=None,
2236        region=None,
2237        role_arn=None,
2238        role_external_id=None,
2239        secret_access_key=None,
2240        secret_store_id=None,
2241        tags=None,
2242    ):
2243        self.access_key = access_key if access_key is not None else ''
2244        self.bind_interface = bind_interface if bind_interface is not None else ''
2245        '''
2246         Bind interface
2247        '''
2248        self.egress_filter = egress_filter if egress_filter is not None else ''
2249        '''
2250         A filter applied to the routing logic to pin datasource to nodes.
2251        '''
2252        self.endpoint = endpoint if endpoint is not None else ''
2253        self.healthy = healthy if healthy is not None else False
2254        '''
2255         True if the datasource is reachable and the credentials are valid.
2256        '''
2257        self.id = id if id is not None else ''
2258        '''
2259         Unique identifier of the Resource.
2260        '''
2261        self.name = name if name is not None else ''
2262        '''
2263         Unique human-readable name of the Resource.
2264        '''
2265        self.port_override = port_override if port_override is not None else 0
2266        self.region = region if region is not None else ''
2267        self.role_arn = role_arn if role_arn is not None else ''
2268        self.role_external_id = role_external_id if role_external_id is not None else ''
2269        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2270        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2271        '''
2272         ID of the secret store containing credentials for this resource, if any.
2273        '''
2274        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2275        '''
2276         Tags is a map of key, value pairs.
2277        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2297    def to_dict(self):
2298        return {
2299            'access_key': self.access_key,
2300            'bind_interface': self.bind_interface,
2301            'egress_filter': self.egress_filter,
2302            'endpoint': self.endpoint,
2303            'healthy': self.healthy,
2304            'id': self.id,
2305            'name': self.name,
2306            'port_override': self.port_override,
2307            'region': self.region,
2308            'role_arn': self.role_arn,
2309            'role_external_id': self.role_external_id,
2310            'secret_access_key': self.secret_access_key,
2311            'secret_store_id': self.secret_store_id,
2312            'tags': self.tags,
2313        }
@classmethod
def from_dict(cls, d)
2315    @classmethod
2316    def from_dict(cls, d):
2317        return cls(
2318            access_key=d.get('access_key'),
2319            bind_interface=d.get('bind_interface'),
2320            egress_filter=d.get('egress_filter'),
2321            endpoint=d.get('endpoint'),
2322            healthy=d.get('healthy'),
2323            id=d.get('id'),
2324            name=d.get('name'),
2325            port_override=d.get('port_override'),
2326            region=d.get('region'),
2327            role_arn=d.get('role_arn'),
2328            role_external_id=d.get('role_external_id'),
2329            secret_access_key=d.get('secret_access_key'),
2330            secret_store_id=d.get('secret_store_id'),
2331            tags=d.get('tags'),
2332        )
class AmazonMQAMQP091:
2335class AmazonMQAMQP091:
2336    __slots__ = [
2337        'bind_interface',
2338        'egress_filter',
2339        'healthy',
2340        'hostname',
2341        'id',
2342        'name',
2343        'password',
2344        'port',
2345        'port_override',
2346        'secret_store_id',
2347        'tags',
2348        'tls_required',
2349        'username',
2350    ]
2351
2352    def __init__(
2353        self,
2354        bind_interface=None,
2355        egress_filter=None,
2356        healthy=None,
2357        hostname=None,
2358        id=None,
2359        name=None,
2360        password=None,
2361        port=None,
2362        port_override=None,
2363        secret_store_id=None,
2364        tags=None,
2365        tls_required=None,
2366        username=None,
2367    ):
2368        self.bind_interface = bind_interface if bind_interface is not None else ''
2369        '''
2370         Bind interface
2371        '''
2372        self.egress_filter = egress_filter if egress_filter is not None else ''
2373        '''
2374         A filter applied to the routing logic to pin datasource to nodes.
2375        '''
2376        self.healthy = healthy if healthy is not None else False
2377        '''
2378         True if the datasource is reachable and the credentials are valid.
2379        '''
2380        self.hostname = hostname if hostname is not None else ''
2381        self.id = id if id is not None else ''
2382        '''
2383         Unique identifier of the Resource.
2384        '''
2385        self.name = name if name is not None else ''
2386        '''
2387         Unique human-readable name of the Resource.
2388        '''
2389        self.password = password if password is not None else ''
2390        self.port = port if port is not None else 0
2391        self.port_override = port_override if port_override is not None else 0
2392        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2393        '''
2394         ID of the secret store containing credentials for this resource, if any.
2395        '''
2396        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2397        '''
2398         Tags is a map of key, value pairs.
2399        '''
2400        self.tls_required = tls_required if tls_required is not None else False
2401        self.username = username if username is not None else ''
2402
2403    def __repr__(self):
2404        return '<sdm.AmazonMQAMQP091 ' + \
2405            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2406            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2407            'healthy: ' + repr(self.healthy) + ' ' +\
2408            'hostname: ' + repr(self.hostname) + ' ' +\
2409            'id: ' + repr(self.id) + ' ' +\
2410            'name: ' + repr(self.name) + ' ' +\
2411            'password: ' + repr(self.password) + ' ' +\
2412            'port: ' + repr(self.port) + ' ' +\
2413            'port_override: ' + repr(self.port_override) + ' ' +\
2414            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2415            'tags: ' + repr(self.tags) + ' ' +\
2416            'tls_required: ' + repr(self.tls_required) + ' ' +\
2417            'username: ' + repr(self.username) + ' ' +\
2418            '>'
2419
2420    def to_dict(self):
2421        return {
2422            'bind_interface': self.bind_interface,
2423            'egress_filter': self.egress_filter,
2424            'healthy': self.healthy,
2425            'hostname': self.hostname,
2426            'id': self.id,
2427            'name': self.name,
2428            'password': self.password,
2429            'port': self.port,
2430            'port_override': self.port_override,
2431            'secret_store_id': self.secret_store_id,
2432            'tags': self.tags,
2433            'tls_required': self.tls_required,
2434            'username': self.username,
2435        }
2436
2437    @classmethod
2438    def from_dict(cls, d):
2439        return cls(
2440            bind_interface=d.get('bind_interface'),
2441            egress_filter=d.get('egress_filter'),
2442            healthy=d.get('healthy'),
2443            hostname=d.get('hostname'),
2444            id=d.get('id'),
2445            name=d.get('name'),
2446            password=d.get('password'),
2447            port=d.get('port'),
2448            port_override=d.get('port_override'),
2449            secret_store_id=d.get('secret_store_id'),
2450            tags=d.get('tags'),
2451            tls_required=d.get('tls_required'),
2452            username=d.get('username'),
2453        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2352    def __init__(
2353        self,
2354        bind_interface=None,
2355        egress_filter=None,
2356        healthy=None,
2357        hostname=None,
2358        id=None,
2359        name=None,
2360        password=None,
2361        port=None,
2362        port_override=None,
2363        secret_store_id=None,
2364        tags=None,
2365        tls_required=None,
2366        username=None,
2367    ):
2368        self.bind_interface = bind_interface if bind_interface is not None else ''
2369        '''
2370         Bind interface
2371        '''
2372        self.egress_filter = egress_filter if egress_filter is not None else ''
2373        '''
2374         A filter applied to the routing logic to pin datasource to nodes.
2375        '''
2376        self.healthy = healthy if healthy is not None else False
2377        '''
2378         True if the datasource is reachable and the credentials are valid.
2379        '''
2380        self.hostname = hostname if hostname is not None else ''
2381        self.id = id if id is not None else ''
2382        '''
2383         Unique identifier of the Resource.
2384        '''
2385        self.name = name if name is not None else ''
2386        '''
2387         Unique human-readable name of the Resource.
2388        '''
2389        self.password = password if password is not None else ''
2390        self.port = port if port is not None else 0
2391        self.port_override = port_override if port_override is not None else 0
2392        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2393        '''
2394         ID of the secret store containing credentials for this resource, if any.
2395        '''
2396        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2397        '''
2398         Tags is a map of key, value pairs.
2399        '''
2400        self.tls_required = tls_required if tls_required is not None else False
2401        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2420    def to_dict(self):
2421        return {
2422            'bind_interface': self.bind_interface,
2423            'egress_filter': self.egress_filter,
2424            'healthy': self.healthy,
2425            'hostname': self.hostname,
2426            'id': self.id,
2427            'name': self.name,
2428            'password': self.password,
2429            'port': self.port,
2430            'port_override': self.port_override,
2431            'secret_store_id': self.secret_store_id,
2432            'tags': self.tags,
2433            'tls_required': self.tls_required,
2434            'username': self.username,
2435        }
@classmethod
def from_dict(cls, d)
2437    @classmethod
2438    def from_dict(cls, d):
2439        return cls(
2440            bind_interface=d.get('bind_interface'),
2441            egress_filter=d.get('egress_filter'),
2442            healthy=d.get('healthy'),
2443            hostname=d.get('hostname'),
2444            id=d.get('id'),
2445            name=d.get('name'),
2446            password=d.get('password'),
2447            port=d.get('port'),
2448            port_override=d.get('port_override'),
2449            secret_store_id=d.get('secret_store_id'),
2450            tags=d.get('tags'),
2451            tls_required=d.get('tls_required'),
2452            username=d.get('username'),
2453        )
class Athena:
2456class Athena:
2457    __slots__ = [
2458        'access_key',
2459        'bind_interface',
2460        'egress_filter',
2461        'healthy',
2462        'id',
2463        'name',
2464        'output',
2465        'port_override',
2466        'region',
2467        'role_arn',
2468        'role_external_id',
2469        'secret_access_key',
2470        'secret_store_id',
2471        'tags',
2472    ]
2473
2474    def __init__(
2475        self,
2476        access_key=None,
2477        bind_interface=None,
2478        egress_filter=None,
2479        healthy=None,
2480        id=None,
2481        name=None,
2482        output=None,
2483        port_override=None,
2484        region=None,
2485        role_arn=None,
2486        role_external_id=None,
2487        secret_access_key=None,
2488        secret_store_id=None,
2489        tags=None,
2490    ):
2491        self.access_key = access_key if access_key is not None else ''
2492        self.bind_interface = bind_interface if bind_interface is not None else ''
2493        '''
2494         Bind interface
2495        '''
2496        self.egress_filter = egress_filter if egress_filter is not None else ''
2497        '''
2498         A filter applied to the routing logic to pin datasource to nodes.
2499        '''
2500        self.healthy = healthy if healthy is not None else False
2501        '''
2502         True if the datasource is reachable and the credentials are valid.
2503        '''
2504        self.id = id if id is not None else ''
2505        '''
2506         Unique identifier of the Resource.
2507        '''
2508        self.name = name if name is not None else ''
2509        '''
2510         Unique human-readable name of the Resource.
2511        '''
2512        self.output = output if output is not None else ''
2513        self.port_override = port_override if port_override is not None else 0
2514        self.region = region if region is not None else ''
2515        self.role_arn = role_arn if role_arn is not None else ''
2516        self.role_external_id = role_external_id if role_external_id is not None else ''
2517        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2518        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2519        '''
2520         ID of the secret store containing credentials for this resource, if any.
2521        '''
2522        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2523        '''
2524         Tags is a map of key, value pairs.
2525        '''
2526
2527    def __repr__(self):
2528        return '<sdm.Athena ' + \
2529            'access_key: ' + repr(self.access_key) + ' ' +\
2530            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2531            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2532            'healthy: ' + repr(self.healthy) + ' ' +\
2533            'id: ' + repr(self.id) + ' ' +\
2534            'name: ' + repr(self.name) + ' ' +\
2535            'output: ' + repr(self.output) + ' ' +\
2536            'port_override: ' + repr(self.port_override) + ' ' +\
2537            'region: ' + repr(self.region) + ' ' +\
2538            'role_arn: ' + repr(self.role_arn) + ' ' +\
2539            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2540            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2541            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2542            'tags: ' + repr(self.tags) + ' ' +\
2543            '>'
2544
2545    def to_dict(self):
2546        return {
2547            'access_key': self.access_key,
2548            'bind_interface': self.bind_interface,
2549            'egress_filter': self.egress_filter,
2550            'healthy': self.healthy,
2551            'id': self.id,
2552            'name': self.name,
2553            'output': self.output,
2554            'port_override': self.port_override,
2555            'region': self.region,
2556            'role_arn': self.role_arn,
2557            'role_external_id': self.role_external_id,
2558            'secret_access_key': self.secret_access_key,
2559            'secret_store_id': self.secret_store_id,
2560            'tags': self.tags,
2561        }
2562
2563    @classmethod
2564    def from_dict(cls, d):
2565        return cls(
2566            access_key=d.get('access_key'),
2567            bind_interface=d.get('bind_interface'),
2568            egress_filter=d.get('egress_filter'),
2569            healthy=d.get('healthy'),
2570            id=d.get('id'),
2571            name=d.get('name'),
2572            output=d.get('output'),
2573            port_override=d.get('port_override'),
2574            region=d.get('region'),
2575            role_arn=d.get('role_arn'),
2576            role_external_id=d.get('role_external_id'),
2577            secret_access_key=d.get('secret_access_key'),
2578            secret_store_id=d.get('secret_store_id'),
2579            tags=d.get('tags'),
2580        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2474    def __init__(
2475        self,
2476        access_key=None,
2477        bind_interface=None,
2478        egress_filter=None,
2479        healthy=None,
2480        id=None,
2481        name=None,
2482        output=None,
2483        port_override=None,
2484        region=None,
2485        role_arn=None,
2486        role_external_id=None,
2487        secret_access_key=None,
2488        secret_store_id=None,
2489        tags=None,
2490    ):
2491        self.access_key = access_key if access_key is not None else ''
2492        self.bind_interface = bind_interface if bind_interface is not None else ''
2493        '''
2494         Bind interface
2495        '''
2496        self.egress_filter = egress_filter if egress_filter is not None else ''
2497        '''
2498         A filter applied to the routing logic to pin datasource to nodes.
2499        '''
2500        self.healthy = healthy if healthy is not None else False
2501        '''
2502         True if the datasource is reachable and the credentials are valid.
2503        '''
2504        self.id = id if id is not None else ''
2505        '''
2506         Unique identifier of the Resource.
2507        '''
2508        self.name = name if name is not None else ''
2509        '''
2510         Unique human-readable name of the Resource.
2511        '''
2512        self.output = output if output is not None else ''
2513        self.port_override = port_override if port_override is not None else 0
2514        self.region = region if region is not None else ''
2515        self.role_arn = role_arn if role_arn is not None else ''
2516        self.role_external_id = role_external_id if role_external_id is not None else ''
2517        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2518        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2519        '''
2520         ID of the secret store containing credentials for this resource, if any.
2521        '''
2522        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2523        '''
2524         Tags is a map of key, value pairs.
2525        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2545    def to_dict(self):
2546        return {
2547            'access_key': self.access_key,
2548            'bind_interface': self.bind_interface,
2549            'egress_filter': self.egress_filter,
2550            'healthy': self.healthy,
2551            'id': self.id,
2552            'name': self.name,
2553            'output': self.output,
2554            'port_override': self.port_override,
2555            'region': self.region,
2556            'role_arn': self.role_arn,
2557            'role_external_id': self.role_external_id,
2558            'secret_access_key': self.secret_access_key,
2559            'secret_store_id': self.secret_store_id,
2560            'tags': self.tags,
2561        }
@classmethod
def from_dict(cls, d)
2563    @classmethod
2564    def from_dict(cls, d):
2565        return cls(
2566            access_key=d.get('access_key'),
2567            bind_interface=d.get('bind_interface'),
2568            egress_filter=d.get('egress_filter'),
2569            healthy=d.get('healthy'),
2570            id=d.get('id'),
2571            name=d.get('name'),
2572            output=d.get('output'),
2573            port_override=d.get('port_override'),
2574            region=d.get('region'),
2575            role_arn=d.get('role_arn'),
2576            role_external_id=d.get('role_external_id'),
2577            secret_access_key=d.get('secret_access_key'),
2578            secret_store_id=d.get('secret_store_id'),
2579            tags=d.get('tags'),
2580        )
class AuroraMysql:
2583class AuroraMysql:
2584    __slots__ = [
2585        'bind_interface',
2586        'database',
2587        'egress_filter',
2588        'healthy',
2589        'hostname',
2590        'id',
2591        'name',
2592        'password',
2593        'port',
2594        'port_override',
2595        'secret_store_id',
2596        'tags',
2597        'username',
2598    ]
2599
2600    def __init__(
2601        self,
2602        bind_interface=None,
2603        database=None,
2604        egress_filter=None,
2605        healthy=None,
2606        hostname=None,
2607        id=None,
2608        name=None,
2609        password=None,
2610        port=None,
2611        port_override=None,
2612        secret_store_id=None,
2613        tags=None,
2614        username=None,
2615    ):
2616        self.bind_interface = bind_interface if bind_interface is not None else ''
2617        '''
2618         Bind interface
2619        '''
2620        self.database = database if database is not None else ''
2621        self.egress_filter = egress_filter if egress_filter is not None else ''
2622        '''
2623         A filter applied to the routing logic to pin datasource to nodes.
2624        '''
2625        self.healthy = healthy if healthy is not None else False
2626        '''
2627         True if the datasource is reachable and the credentials are valid.
2628        '''
2629        self.hostname = hostname if hostname is not None else ''
2630        self.id = id if id is not None else ''
2631        '''
2632         Unique identifier of the Resource.
2633        '''
2634        self.name = name if name is not None else ''
2635        '''
2636         Unique human-readable name of the Resource.
2637        '''
2638        self.password = password if password is not None else ''
2639        self.port = port if port is not None else 0
2640        self.port_override = port_override if port_override is not None else 0
2641        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2642        '''
2643         ID of the secret store containing credentials for this resource, if any.
2644        '''
2645        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2646        '''
2647         Tags is a map of key, value pairs.
2648        '''
2649        self.username = username if username is not None else ''
2650
2651    def __repr__(self):
2652        return '<sdm.AuroraMysql ' + \
2653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2654            'database: ' + repr(self.database) + ' ' +\
2655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2656            'healthy: ' + repr(self.healthy) + ' ' +\
2657            'hostname: ' + repr(self.hostname) + ' ' +\
2658            'id: ' + repr(self.id) + ' ' +\
2659            'name: ' + repr(self.name) + ' ' +\
2660            'password: ' + repr(self.password) + ' ' +\
2661            'port: ' + repr(self.port) + ' ' +\
2662            'port_override: ' + repr(self.port_override) + ' ' +\
2663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2664            'tags: ' + repr(self.tags) + ' ' +\
2665            'username: ' + repr(self.username) + ' ' +\
2666            '>'
2667
2668    def to_dict(self):
2669        return {
2670            'bind_interface': self.bind_interface,
2671            'database': self.database,
2672            'egress_filter': self.egress_filter,
2673            'healthy': self.healthy,
2674            'hostname': self.hostname,
2675            'id': self.id,
2676            'name': self.name,
2677            'password': self.password,
2678            'port': self.port,
2679            'port_override': self.port_override,
2680            'secret_store_id': self.secret_store_id,
2681            'tags': self.tags,
2682            'username': self.username,
2683        }
2684
2685    @classmethod
2686    def from_dict(cls, d):
2687        return cls(
2688            bind_interface=d.get('bind_interface'),
2689            database=d.get('database'),
2690            egress_filter=d.get('egress_filter'),
2691            healthy=d.get('healthy'),
2692            hostname=d.get('hostname'),
2693            id=d.get('id'),
2694            name=d.get('name'),
2695            password=d.get('password'),
2696            port=d.get('port'),
2697            port_override=d.get('port_override'),
2698            secret_store_id=d.get('secret_store_id'),
2699            tags=d.get('tags'),
2700            username=d.get('username'),
2701        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2600    def __init__(
2601        self,
2602        bind_interface=None,
2603        database=None,
2604        egress_filter=None,
2605        healthy=None,
2606        hostname=None,
2607        id=None,
2608        name=None,
2609        password=None,
2610        port=None,
2611        port_override=None,
2612        secret_store_id=None,
2613        tags=None,
2614        username=None,
2615    ):
2616        self.bind_interface = bind_interface if bind_interface is not None else ''
2617        '''
2618         Bind interface
2619        '''
2620        self.database = database if database is not None else ''
2621        self.egress_filter = egress_filter if egress_filter is not None else ''
2622        '''
2623         A filter applied to the routing logic to pin datasource to nodes.
2624        '''
2625        self.healthy = healthy if healthy is not None else False
2626        '''
2627         True if the datasource is reachable and the credentials are valid.
2628        '''
2629        self.hostname = hostname if hostname is not None else ''
2630        self.id = id if id is not None else ''
2631        '''
2632         Unique identifier of the Resource.
2633        '''
2634        self.name = name if name is not None else ''
2635        '''
2636         Unique human-readable name of the Resource.
2637        '''
2638        self.password = password if password is not None else ''
2639        self.port = port if port is not None else 0
2640        self.port_override = port_override if port_override is not None else 0
2641        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2642        '''
2643         ID of the secret store containing credentials for this resource, if any.
2644        '''
2645        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2646        '''
2647         Tags is a map of key, value pairs.
2648        '''
2649        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2668    def to_dict(self):
2669        return {
2670            'bind_interface': self.bind_interface,
2671            'database': self.database,
2672            'egress_filter': self.egress_filter,
2673            'healthy': self.healthy,
2674            'hostname': self.hostname,
2675            'id': self.id,
2676            'name': self.name,
2677            'password': self.password,
2678            'port': self.port,
2679            'port_override': self.port_override,
2680            'secret_store_id': self.secret_store_id,
2681            'tags': self.tags,
2682            'username': self.username,
2683        }
@classmethod
def from_dict(cls, d)
2685    @classmethod
2686    def from_dict(cls, d):
2687        return cls(
2688            bind_interface=d.get('bind_interface'),
2689            database=d.get('database'),
2690            egress_filter=d.get('egress_filter'),
2691            healthy=d.get('healthy'),
2692            hostname=d.get('hostname'),
2693            id=d.get('id'),
2694            name=d.get('name'),
2695            password=d.get('password'),
2696            port=d.get('port'),
2697            port_override=d.get('port_override'),
2698            secret_store_id=d.get('secret_store_id'),
2699            tags=d.get('tags'),
2700            username=d.get('username'),
2701        )
class AuroraPostgres:
2704class AuroraPostgres:
2705    __slots__ = [
2706        'bind_interface',
2707        'database',
2708        'egress_filter',
2709        'healthy',
2710        'hostname',
2711        'id',
2712        'name',
2713        'override_database',
2714        'password',
2715        'port',
2716        'port_override',
2717        'secret_store_id',
2718        'tags',
2719        'username',
2720    ]
2721
2722    def __init__(
2723        self,
2724        bind_interface=None,
2725        database=None,
2726        egress_filter=None,
2727        healthy=None,
2728        hostname=None,
2729        id=None,
2730        name=None,
2731        override_database=None,
2732        password=None,
2733        port=None,
2734        port_override=None,
2735        secret_store_id=None,
2736        tags=None,
2737        username=None,
2738    ):
2739        self.bind_interface = bind_interface if bind_interface is not None else ''
2740        '''
2741         Bind interface
2742        '''
2743        self.database = database if database is not None else ''
2744        self.egress_filter = egress_filter if egress_filter is not None else ''
2745        '''
2746         A filter applied to the routing logic to pin datasource to nodes.
2747        '''
2748        self.healthy = healthy if healthy is not None else False
2749        '''
2750         True if the datasource is reachable and the credentials are valid.
2751        '''
2752        self.hostname = hostname if hostname is not None else ''
2753        self.id = id if id is not None else ''
2754        '''
2755         Unique identifier of the Resource.
2756        '''
2757        self.name = name if name is not None else ''
2758        '''
2759         Unique human-readable name of the Resource.
2760        '''
2761        self.override_database = override_database if override_database is not None else False
2762        self.password = password if password is not None else ''
2763        self.port = port if port is not None else 0
2764        self.port_override = port_override if port_override is not None else 0
2765        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2766        '''
2767         ID of the secret store containing credentials for this resource, if any.
2768        '''
2769        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2770        '''
2771         Tags is a map of key, value pairs.
2772        '''
2773        self.username = username if username is not None else ''
2774
2775    def __repr__(self):
2776        return '<sdm.AuroraPostgres ' + \
2777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2778            'database: ' + repr(self.database) + ' ' +\
2779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2780            'healthy: ' + repr(self.healthy) + ' ' +\
2781            'hostname: ' + repr(self.hostname) + ' ' +\
2782            'id: ' + repr(self.id) + ' ' +\
2783            'name: ' + repr(self.name) + ' ' +\
2784            'override_database: ' + repr(self.override_database) + ' ' +\
2785            'password: ' + repr(self.password) + ' ' +\
2786            'port: ' + repr(self.port) + ' ' +\
2787            'port_override: ' + repr(self.port_override) + ' ' +\
2788            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2789            'tags: ' + repr(self.tags) + ' ' +\
2790            'username: ' + repr(self.username) + ' ' +\
2791            '>'
2792
2793    def to_dict(self):
2794        return {
2795            'bind_interface': self.bind_interface,
2796            'database': self.database,
2797            'egress_filter': self.egress_filter,
2798            'healthy': self.healthy,
2799            'hostname': self.hostname,
2800            'id': self.id,
2801            'name': self.name,
2802            'override_database': self.override_database,
2803            'password': self.password,
2804            'port': self.port,
2805            'port_override': self.port_override,
2806            'secret_store_id': self.secret_store_id,
2807            'tags': self.tags,
2808            'username': self.username,
2809        }
2810
2811    @classmethod
2812    def from_dict(cls, d):
2813        return cls(
2814            bind_interface=d.get('bind_interface'),
2815            database=d.get('database'),
2816            egress_filter=d.get('egress_filter'),
2817            healthy=d.get('healthy'),
2818            hostname=d.get('hostname'),
2819            id=d.get('id'),
2820            name=d.get('name'),
2821            override_database=d.get('override_database'),
2822            password=d.get('password'),
2823            port=d.get('port'),
2824            port_override=d.get('port_override'),
2825            secret_store_id=d.get('secret_store_id'),
2826            tags=d.get('tags'),
2827            username=d.get('username'),
2828        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2722    def __init__(
2723        self,
2724        bind_interface=None,
2725        database=None,
2726        egress_filter=None,
2727        healthy=None,
2728        hostname=None,
2729        id=None,
2730        name=None,
2731        override_database=None,
2732        password=None,
2733        port=None,
2734        port_override=None,
2735        secret_store_id=None,
2736        tags=None,
2737        username=None,
2738    ):
2739        self.bind_interface = bind_interface if bind_interface is not None else ''
2740        '''
2741         Bind interface
2742        '''
2743        self.database = database if database is not None else ''
2744        self.egress_filter = egress_filter if egress_filter is not None else ''
2745        '''
2746         A filter applied to the routing logic to pin datasource to nodes.
2747        '''
2748        self.healthy = healthy if healthy is not None else False
2749        '''
2750         True if the datasource is reachable and the credentials are valid.
2751        '''
2752        self.hostname = hostname if hostname is not None else ''
2753        self.id = id if id is not None else ''
2754        '''
2755         Unique identifier of the Resource.
2756        '''
2757        self.name = name if name is not None else ''
2758        '''
2759         Unique human-readable name of the Resource.
2760        '''
2761        self.override_database = override_database if override_database is not None else False
2762        self.password = password if password is not None else ''
2763        self.port = port if port is not None else 0
2764        self.port_override = port_override if port_override is not None else 0
2765        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2766        '''
2767         ID of the secret store containing credentials for this resource, if any.
2768        '''
2769        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2770        '''
2771         Tags is a map of key, value pairs.
2772        '''
2773        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2793    def to_dict(self):
2794        return {
2795            'bind_interface': self.bind_interface,
2796            'database': self.database,
2797            'egress_filter': self.egress_filter,
2798            'healthy': self.healthy,
2799            'hostname': self.hostname,
2800            'id': self.id,
2801            'name': self.name,
2802            'override_database': self.override_database,
2803            'password': self.password,
2804            'port': self.port,
2805            'port_override': self.port_override,
2806            'secret_store_id': self.secret_store_id,
2807            'tags': self.tags,
2808            'username': self.username,
2809        }
@classmethod
def from_dict(cls, d)
2811    @classmethod
2812    def from_dict(cls, d):
2813        return cls(
2814            bind_interface=d.get('bind_interface'),
2815            database=d.get('database'),
2816            egress_filter=d.get('egress_filter'),
2817            healthy=d.get('healthy'),
2818            hostname=d.get('hostname'),
2819            id=d.get('id'),
2820            name=d.get('name'),
2821            override_database=d.get('override_database'),
2822            password=d.get('password'),
2823            port=d.get('port'),
2824            port_override=d.get('port_override'),
2825            secret_store_id=d.get('secret_store_id'),
2826            tags=d.get('tags'),
2827            username=d.get('username'),
2828        )
class Azure:
2831class Azure:
2832    __slots__ = [
2833        'app_id',
2834        'bind_interface',
2835        'egress_filter',
2836        'healthy',
2837        'id',
2838        'name',
2839        'password',
2840        'secret_store_id',
2841        'tags',
2842        'tenant_id',
2843    ]
2844
2845    def __init__(
2846        self,
2847        app_id=None,
2848        bind_interface=None,
2849        egress_filter=None,
2850        healthy=None,
2851        id=None,
2852        name=None,
2853        password=None,
2854        secret_store_id=None,
2855        tags=None,
2856        tenant_id=None,
2857    ):
2858        self.app_id = app_id if app_id is not None else ''
2859        self.bind_interface = bind_interface if bind_interface is not None else ''
2860        '''
2861         Bind interface
2862        '''
2863        self.egress_filter = egress_filter if egress_filter is not None else ''
2864        '''
2865         A filter applied to the routing logic to pin datasource to nodes.
2866        '''
2867        self.healthy = healthy if healthy is not None else False
2868        '''
2869         True if the datasource is reachable and the credentials are valid.
2870        '''
2871        self.id = id if id is not None else ''
2872        '''
2873         Unique identifier of the Resource.
2874        '''
2875        self.name = name if name is not None else ''
2876        '''
2877         Unique human-readable name of the Resource.
2878        '''
2879        self.password = password if password is not None else ''
2880        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2881        '''
2882         ID of the secret store containing credentials for this resource, if any.
2883        '''
2884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2885        '''
2886         Tags is a map of key, value pairs.
2887        '''
2888        self.tenant_id = tenant_id if tenant_id is not None else ''
2889
2890    def __repr__(self):
2891        return '<sdm.Azure ' + \
2892            'app_id: ' + repr(self.app_id) + ' ' +\
2893            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2894            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2895            'healthy: ' + repr(self.healthy) + ' ' +\
2896            'id: ' + repr(self.id) + ' ' +\
2897            'name: ' + repr(self.name) + ' ' +\
2898            'password: ' + repr(self.password) + ' ' +\
2899            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2900            'tags: ' + repr(self.tags) + ' ' +\
2901            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2902            '>'
2903
2904    def to_dict(self):
2905        return {
2906            'app_id': self.app_id,
2907            'bind_interface': self.bind_interface,
2908            'egress_filter': self.egress_filter,
2909            'healthy': self.healthy,
2910            'id': self.id,
2911            'name': self.name,
2912            'password': self.password,
2913            'secret_store_id': self.secret_store_id,
2914            'tags': self.tags,
2915            'tenant_id': self.tenant_id,
2916        }
2917
2918    @classmethod
2919    def from_dict(cls, d):
2920        return cls(
2921            app_id=d.get('app_id'),
2922            bind_interface=d.get('bind_interface'),
2923            egress_filter=d.get('egress_filter'),
2924            healthy=d.get('healthy'),
2925            id=d.get('id'),
2926            name=d.get('name'),
2927            password=d.get('password'),
2928            secret_store_id=d.get('secret_store_id'),
2929            tags=d.get('tags'),
2930            tenant_id=d.get('tenant_id'),
2931        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2845    def __init__(
2846        self,
2847        app_id=None,
2848        bind_interface=None,
2849        egress_filter=None,
2850        healthy=None,
2851        id=None,
2852        name=None,
2853        password=None,
2854        secret_store_id=None,
2855        tags=None,
2856        tenant_id=None,
2857    ):
2858        self.app_id = app_id if app_id is not None else ''
2859        self.bind_interface = bind_interface if bind_interface is not None else ''
2860        '''
2861         Bind interface
2862        '''
2863        self.egress_filter = egress_filter if egress_filter is not None else ''
2864        '''
2865         A filter applied to the routing logic to pin datasource to nodes.
2866        '''
2867        self.healthy = healthy if healthy is not None else False
2868        '''
2869         True if the datasource is reachable and the credentials are valid.
2870        '''
2871        self.id = id if id is not None else ''
2872        '''
2873         Unique identifier of the Resource.
2874        '''
2875        self.name = name if name is not None else ''
2876        '''
2877         Unique human-readable name of the Resource.
2878        '''
2879        self.password = password if password is not None else ''
2880        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2881        '''
2882         ID of the secret store containing credentials for this resource, if any.
2883        '''
2884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2885        '''
2886         Tags is a map of key, value pairs.
2887        '''
2888        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2904    def to_dict(self):
2905        return {
2906            'app_id': self.app_id,
2907            'bind_interface': self.bind_interface,
2908            'egress_filter': self.egress_filter,
2909            'healthy': self.healthy,
2910            'id': self.id,
2911            'name': self.name,
2912            'password': self.password,
2913            'secret_store_id': self.secret_store_id,
2914            'tags': self.tags,
2915            'tenant_id': self.tenant_id,
2916        }
@classmethod
def from_dict(cls, d)
2918    @classmethod
2919    def from_dict(cls, d):
2920        return cls(
2921            app_id=d.get('app_id'),
2922            bind_interface=d.get('bind_interface'),
2923            egress_filter=d.get('egress_filter'),
2924            healthy=d.get('healthy'),
2925            id=d.get('id'),
2926            name=d.get('name'),
2927            password=d.get('password'),
2928            secret_store_id=d.get('secret_store_id'),
2929            tags=d.get('tags'),
2930            tenant_id=d.get('tenant_id'),
2931        )
class AzureCertificate:
2934class AzureCertificate:
2935    __slots__ = [
2936        'app_id',
2937        'bind_interface',
2938        'client_certificate',
2939        'egress_filter',
2940        'healthy',
2941        'id',
2942        'name',
2943        'secret_store_id',
2944        'tags',
2945        'tenant_id',
2946    ]
2947
2948    def __init__(
2949        self,
2950        app_id=None,
2951        bind_interface=None,
2952        client_certificate=None,
2953        egress_filter=None,
2954        healthy=None,
2955        id=None,
2956        name=None,
2957        secret_store_id=None,
2958        tags=None,
2959        tenant_id=None,
2960    ):
2961        self.app_id = app_id if app_id is not None else ''
2962        self.bind_interface = bind_interface if bind_interface is not None else ''
2963        '''
2964         Bind interface
2965        '''
2966        self.client_certificate = client_certificate if client_certificate is not None else ''
2967        self.egress_filter = egress_filter if egress_filter is not None else ''
2968        '''
2969         A filter applied to the routing logic to pin datasource to nodes.
2970        '''
2971        self.healthy = healthy if healthy is not None else False
2972        '''
2973         True if the datasource is reachable and the credentials are valid.
2974        '''
2975        self.id = id if id is not None else ''
2976        '''
2977         Unique identifier of the Resource.
2978        '''
2979        self.name = name if name is not None else ''
2980        '''
2981         Unique human-readable name of the Resource.
2982        '''
2983        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2984        '''
2985         ID of the secret store containing credentials for this resource, if any.
2986        '''
2987        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2988        '''
2989         Tags is a map of key, value pairs.
2990        '''
2991        self.tenant_id = tenant_id if tenant_id is not None else ''
2992
2993    def __repr__(self):
2994        return '<sdm.AzureCertificate ' + \
2995            'app_id: ' + repr(self.app_id) + ' ' +\
2996            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2997            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2998            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2999            'healthy: ' + repr(self.healthy) + ' ' +\
3000            'id: ' + repr(self.id) + ' ' +\
3001            'name: ' + repr(self.name) + ' ' +\
3002            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3003            'tags: ' + repr(self.tags) + ' ' +\
3004            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
3005            '>'
3006
3007    def to_dict(self):
3008        return {
3009            'app_id': self.app_id,
3010            'bind_interface': self.bind_interface,
3011            'client_certificate': self.client_certificate,
3012            'egress_filter': self.egress_filter,
3013            'healthy': self.healthy,
3014            'id': self.id,
3015            'name': self.name,
3016            'secret_store_id': self.secret_store_id,
3017            'tags': self.tags,
3018            'tenant_id': self.tenant_id,
3019        }
3020
3021    @classmethod
3022    def from_dict(cls, d):
3023        return cls(
3024            app_id=d.get('app_id'),
3025            bind_interface=d.get('bind_interface'),
3026            client_certificate=d.get('client_certificate'),
3027            egress_filter=d.get('egress_filter'),
3028            healthy=d.get('healthy'),
3029            id=d.get('id'),
3030            name=d.get('name'),
3031            secret_store_id=d.get('secret_store_id'),
3032            tags=d.get('tags'),
3033            tenant_id=d.get('tenant_id'),
3034        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2948    def __init__(
2949        self,
2950        app_id=None,
2951        bind_interface=None,
2952        client_certificate=None,
2953        egress_filter=None,
2954        healthy=None,
2955        id=None,
2956        name=None,
2957        secret_store_id=None,
2958        tags=None,
2959        tenant_id=None,
2960    ):
2961        self.app_id = app_id if app_id is not None else ''
2962        self.bind_interface = bind_interface if bind_interface is not None else ''
2963        '''
2964         Bind interface
2965        '''
2966        self.client_certificate = client_certificate if client_certificate is not None else ''
2967        self.egress_filter = egress_filter if egress_filter is not None else ''
2968        '''
2969         A filter applied to the routing logic to pin datasource to nodes.
2970        '''
2971        self.healthy = healthy if healthy is not None else False
2972        '''
2973         True if the datasource is reachable and the credentials are valid.
2974        '''
2975        self.id = id if id is not None else ''
2976        '''
2977         Unique identifier of the Resource.
2978        '''
2979        self.name = name if name is not None else ''
2980        '''
2981         Unique human-readable name of the Resource.
2982        '''
2983        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2984        '''
2985         ID of the secret store containing credentials for this resource, if any.
2986        '''
2987        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2988        '''
2989         Tags is a map of key, value pairs.
2990        '''
2991        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
3007    def to_dict(self):
3008        return {
3009            'app_id': self.app_id,
3010            'bind_interface': self.bind_interface,
3011            'client_certificate': self.client_certificate,
3012            'egress_filter': self.egress_filter,
3013            'healthy': self.healthy,
3014            'id': self.id,
3015            'name': self.name,
3016            'secret_store_id': self.secret_store_id,
3017            'tags': self.tags,
3018            'tenant_id': self.tenant_id,
3019        }
@classmethod
def from_dict(cls, d)
3021    @classmethod
3022    def from_dict(cls, d):
3023        return cls(
3024            app_id=d.get('app_id'),
3025            bind_interface=d.get('bind_interface'),
3026            client_certificate=d.get('client_certificate'),
3027            egress_filter=d.get('egress_filter'),
3028            healthy=d.get('healthy'),
3029            id=d.get('id'),
3030            name=d.get('name'),
3031            secret_store_id=d.get('secret_store_id'),
3032            tags=d.get('tags'),
3033            tenant_id=d.get('tenant_id'),
3034        )
class AzureMysql:
3037class AzureMysql:
3038    '''
3039    AzureMysql is currently unstable, and its API may change, or it may be removed,
3040    without a major version bump.
3041    '''
3042    __slots__ = [
3043        'bind_interface',
3044        'database',
3045        'egress_filter',
3046        'healthy',
3047        'hostname',
3048        'id',
3049        'name',
3050        'password',
3051        'port',
3052        'port_override',
3053        'secret_store_id',
3054        'tags',
3055        'username',
3056    ]
3057
3058    def __init__(
3059        self,
3060        bind_interface=None,
3061        database=None,
3062        egress_filter=None,
3063        healthy=None,
3064        hostname=None,
3065        id=None,
3066        name=None,
3067        password=None,
3068        port=None,
3069        port_override=None,
3070        secret_store_id=None,
3071        tags=None,
3072        username=None,
3073    ):
3074        self.bind_interface = bind_interface if bind_interface is not None else ''
3075        '''
3076         Bind interface
3077        '''
3078        self.database = database if database is not None else ''
3079        self.egress_filter = egress_filter if egress_filter is not None else ''
3080        '''
3081         A filter applied to the routing logic to pin datasource to nodes.
3082        '''
3083        self.healthy = healthy if healthy is not None else False
3084        '''
3085         True if the datasource is reachable and the credentials are valid.
3086        '''
3087        self.hostname = hostname if hostname is not None else ''
3088        self.id = id if id is not None else ''
3089        '''
3090         Unique identifier of the Resource.
3091        '''
3092        self.name = name if name is not None else ''
3093        '''
3094         Unique human-readable name of the Resource.
3095        '''
3096        self.password = password if password is not None else ''
3097        self.port = port if port is not None else 0
3098        self.port_override = port_override if port_override is not None else 0
3099        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3100        '''
3101         ID of the secret store containing credentials for this resource, if any.
3102        '''
3103        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3104        '''
3105         Tags is a map of key, value pairs.
3106        '''
3107        self.username = username if username is not None else ''
3108
3109    def __repr__(self):
3110        return '<sdm.AzureMysql ' + \
3111            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3112            'database: ' + repr(self.database) + ' ' +\
3113            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3114            'healthy: ' + repr(self.healthy) + ' ' +\
3115            'hostname: ' + repr(self.hostname) + ' ' +\
3116            'id: ' + repr(self.id) + ' ' +\
3117            'name: ' + repr(self.name) + ' ' +\
3118            'password: ' + repr(self.password) + ' ' +\
3119            'port: ' + repr(self.port) + ' ' +\
3120            'port_override: ' + repr(self.port_override) + ' ' +\
3121            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3122            'tags: ' + repr(self.tags) + ' ' +\
3123            'username: ' + repr(self.username) + ' ' +\
3124            '>'
3125
3126    def to_dict(self):
3127        return {
3128            'bind_interface': self.bind_interface,
3129            'database': self.database,
3130            'egress_filter': self.egress_filter,
3131            'healthy': self.healthy,
3132            'hostname': self.hostname,
3133            'id': self.id,
3134            'name': self.name,
3135            'password': self.password,
3136            'port': self.port,
3137            'port_override': self.port_override,
3138            'secret_store_id': self.secret_store_id,
3139            'tags': self.tags,
3140            'username': self.username,
3141        }
3142
3143    @classmethod
3144    def from_dict(cls, d):
3145        return cls(
3146            bind_interface=d.get('bind_interface'),
3147            database=d.get('database'),
3148            egress_filter=d.get('egress_filter'),
3149            healthy=d.get('healthy'),
3150            hostname=d.get('hostname'),
3151            id=d.get('id'),
3152            name=d.get('name'),
3153            password=d.get('password'),
3154            port=d.get('port'),
3155            port_override=d.get('port_override'),
3156            secret_store_id=d.get('secret_store_id'),
3157            tags=d.get('tags'),
3158            username=d.get('username'),
3159        )

AzureMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

AzureMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3058    def __init__(
3059        self,
3060        bind_interface=None,
3061        database=None,
3062        egress_filter=None,
3063        healthy=None,
3064        hostname=None,
3065        id=None,
3066        name=None,
3067        password=None,
3068        port=None,
3069        port_override=None,
3070        secret_store_id=None,
3071        tags=None,
3072        username=None,
3073    ):
3074        self.bind_interface = bind_interface if bind_interface is not None else ''
3075        '''
3076         Bind interface
3077        '''
3078        self.database = database if database is not None else ''
3079        self.egress_filter = egress_filter if egress_filter is not None else ''
3080        '''
3081         A filter applied to the routing logic to pin datasource to nodes.
3082        '''
3083        self.healthy = healthy if healthy is not None else False
3084        '''
3085         True if the datasource is reachable and the credentials are valid.
3086        '''
3087        self.hostname = hostname if hostname is not None else ''
3088        self.id = id if id is not None else ''
3089        '''
3090         Unique identifier of the Resource.
3091        '''
3092        self.name = name if name is not None else ''
3093        '''
3094         Unique human-readable name of the Resource.
3095        '''
3096        self.password = password if password is not None else ''
3097        self.port = port if port is not None else 0
3098        self.port_override = port_override if port_override is not None else 0
3099        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3100        '''
3101         ID of the secret store containing credentials for this resource, if any.
3102        '''
3103        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3104        '''
3105         Tags is a map of key, value pairs.
3106        '''
3107        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3126    def to_dict(self):
3127        return {
3128            'bind_interface': self.bind_interface,
3129            'database': self.database,
3130            'egress_filter': self.egress_filter,
3131            'healthy': self.healthy,
3132            'hostname': self.hostname,
3133            'id': self.id,
3134            'name': self.name,
3135            'password': self.password,
3136            'port': self.port,
3137            'port_override': self.port_override,
3138            'secret_store_id': self.secret_store_id,
3139            'tags': self.tags,
3140            'username': self.username,
3141        }
@classmethod
def from_dict(cls, d)
3143    @classmethod
3144    def from_dict(cls, d):
3145        return cls(
3146            bind_interface=d.get('bind_interface'),
3147            database=d.get('database'),
3148            egress_filter=d.get('egress_filter'),
3149            healthy=d.get('healthy'),
3150            hostname=d.get('hostname'),
3151            id=d.get('id'),
3152            name=d.get('name'),
3153            password=d.get('password'),
3154            port=d.get('port'),
3155            port_override=d.get('port_override'),
3156            secret_store_id=d.get('secret_store_id'),
3157            tags=d.get('tags'),
3158            username=d.get('username'),
3159        )
class AzurePostgres:
3162class AzurePostgres:
3163    __slots__ = [
3164        'bind_interface',
3165        'database',
3166        'egress_filter',
3167        'healthy',
3168        'hostname',
3169        'id',
3170        'name',
3171        'override_database',
3172        'password',
3173        'port',
3174        'port_override',
3175        'secret_store_id',
3176        'tags',
3177        'username',
3178    ]
3179
3180    def __init__(
3181        self,
3182        bind_interface=None,
3183        database=None,
3184        egress_filter=None,
3185        healthy=None,
3186        hostname=None,
3187        id=None,
3188        name=None,
3189        override_database=None,
3190        password=None,
3191        port=None,
3192        port_override=None,
3193        secret_store_id=None,
3194        tags=None,
3195        username=None,
3196    ):
3197        self.bind_interface = bind_interface if bind_interface is not None else ''
3198        '''
3199         Bind interface
3200        '''
3201        self.database = database if database is not None else ''
3202        self.egress_filter = egress_filter if egress_filter is not None else ''
3203        '''
3204         A filter applied to the routing logic to pin datasource to nodes.
3205        '''
3206        self.healthy = healthy if healthy is not None else False
3207        '''
3208         True if the datasource is reachable and the credentials are valid.
3209        '''
3210        self.hostname = hostname if hostname is not None else ''
3211        self.id = id if id is not None else ''
3212        '''
3213         Unique identifier of the Resource.
3214        '''
3215        self.name = name if name is not None else ''
3216        '''
3217         Unique human-readable name of the Resource.
3218        '''
3219        self.override_database = override_database if override_database is not None else False
3220        self.password = password if password is not None else ''
3221        self.port = port if port is not None else 0
3222        self.port_override = port_override if port_override is not None else 0
3223        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3224        '''
3225         ID of the secret store containing credentials for this resource, if any.
3226        '''
3227        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3228        '''
3229         Tags is a map of key, value pairs.
3230        '''
3231        self.username = username if username is not None else ''
3232
3233    def __repr__(self):
3234        return '<sdm.AzurePostgres ' + \
3235            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3236            'database: ' + repr(self.database) + ' ' +\
3237            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3238            'healthy: ' + repr(self.healthy) + ' ' +\
3239            'hostname: ' + repr(self.hostname) + ' ' +\
3240            'id: ' + repr(self.id) + ' ' +\
3241            'name: ' + repr(self.name) + ' ' +\
3242            'override_database: ' + repr(self.override_database) + ' ' +\
3243            'password: ' + repr(self.password) + ' ' +\
3244            'port: ' + repr(self.port) + ' ' +\
3245            'port_override: ' + repr(self.port_override) + ' ' +\
3246            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3247            'tags: ' + repr(self.tags) + ' ' +\
3248            'username: ' + repr(self.username) + ' ' +\
3249            '>'
3250
3251    def to_dict(self):
3252        return {
3253            'bind_interface': self.bind_interface,
3254            'database': self.database,
3255            'egress_filter': self.egress_filter,
3256            'healthy': self.healthy,
3257            'hostname': self.hostname,
3258            'id': self.id,
3259            'name': self.name,
3260            'override_database': self.override_database,
3261            'password': self.password,
3262            'port': self.port,
3263            'port_override': self.port_override,
3264            'secret_store_id': self.secret_store_id,
3265            'tags': self.tags,
3266            'username': self.username,
3267        }
3268
3269    @classmethod
3270    def from_dict(cls, d):
3271        return cls(
3272            bind_interface=d.get('bind_interface'),
3273            database=d.get('database'),
3274            egress_filter=d.get('egress_filter'),
3275            healthy=d.get('healthy'),
3276            hostname=d.get('hostname'),
3277            id=d.get('id'),
3278            name=d.get('name'),
3279            override_database=d.get('override_database'),
3280            password=d.get('password'),
3281            port=d.get('port'),
3282            port_override=d.get('port_override'),
3283            secret_store_id=d.get('secret_store_id'),
3284            tags=d.get('tags'),
3285            username=d.get('username'),
3286        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3180    def __init__(
3181        self,
3182        bind_interface=None,
3183        database=None,
3184        egress_filter=None,
3185        healthy=None,
3186        hostname=None,
3187        id=None,
3188        name=None,
3189        override_database=None,
3190        password=None,
3191        port=None,
3192        port_override=None,
3193        secret_store_id=None,
3194        tags=None,
3195        username=None,
3196    ):
3197        self.bind_interface = bind_interface if bind_interface is not None else ''
3198        '''
3199         Bind interface
3200        '''
3201        self.database = database if database is not None else ''
3202        self.egress_filter = egress_filter if egress_filter is not None else ''
3203        '''
3204         A filter applied to the routing logic to pin datasource to nodes.
3205        '''
3206        self.healthy = healthy if healthy is not None else False
3207        '''
3208         True if the datasource is reachable and the credentials are valid.
3209        '''
3210        self.hostname = hostname if hostname is not None else ''
3211        self.id = id if id is not None else ''
3212        '''
3213         Unique identifier of the Resource.
3214        '''
3215        self.name = name if name is not None else ''
3216        '''
3217         Unique human-readable name of the Resource.
3218        '''
3219        self.override_database = override_database if override_database is not None else False
3220        self.password = password if password is not None else ''
3221        self.port = port if port is not None else 0
3222        self.port_override = port_override if port_override is not None else 0
3223        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3224        '''
3225         ID of the secret store containing credentials for this resource, if any.
3226        '''
3227        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3228        '''
3229         Tags is a map of key, value pairs.
3230        '''
3231        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3251    def to_dict(self):
3252        return {
3253            'bind_interface': self.bind_interface,
3254            'database': self.database,
3255            'egress_filter': self.egress_filter,
3256            'healthy': self.healthy,
3257            'hostname': self.hostname,
3258            'id': self.id,
3259            'name': self.name,
3260            'override_database': self.override_database,
3261            'password': self.password,
3262            'port': self.port,
3263            'port_override': self.port_override,
3264            'secret_store_id': self.secret_store_id,
3265            'tags': self.tags,
3266            'username': self.username,
3267        }
@classmethod
def from_dict(cls, d)
3269    @classmethod
3270    def from_dict(cls, d):
3271        return cls(
3272            bind_interface=d.get('bind_interface'),
3273            database=d.get('database'),
3274            egress_filter=d.get('egress_filter'),
3275            healthy=d.get('healthy'),
3276            hostname=d.get('hostname'),
3277            id=d.get('id'),
3278            name=d.get('name'),
3279            override_database=d.get('override_database'),
3280            password=d.get('password'),
3281            port=d.get('port'),
3282            port_override=d.get('port_override'),
3283            secret_store_id=d.get('secret_store_id'),
3284            tags=d.get('tags'),
3285            username=d.get('username'),
3286        )
class AzureStore:
3289class AzureStore:
3290    __slots__ = [
3291        'id',
3292        'name',
3293        'tags',
3294        'vault_uri',
3295    ]
3296
3297    def __init__(
3298        self,
3299        id=None,
3300        name=None,
3301        tags=None,
3302        vault_uri=None,
3303    ):
3304        self.id = id if id is not None else ''
3305        '''
3306         Unique identifier of the SecretStore.
3307        '''
3308        self.name = name if name is not None else ''
3309        '''
3310         Unique human-readable name of the SecretStore.
3311        '''
3312        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3313        '''
3314         Tags is a map of key, value pairs.
3315        '''
3316        self.vault_uri = vault_uri if vault_uri is not None else ''
3317
3318    def __repr__(self):
3319        return '<sdm.AzureStore ' + \
3320            'id: ' + repr(self.id) + ' ' +\
3321            'name: ' + repr(self.name) + ' ' +\
3322            'tags: ' + repr(self.tags) + ' ' +\
3323            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3324            '>'
3325
3326    def to_dict(self):
3327        return {
3328            'id': self.id,
3329            'name': self.name,
3330            'tags': self.tags,
3331            'vault_uri': self.vault_uri,
3332        }
3333
3334    @classmethod
3335    def from_dict(cls, d):
3336        return cls(
3337            id=d.get('id'),
3338            name=d.get('name'),
3339            tags=d.get('tags'),
3340            vault_uri=d.get('vault_uri'),
3341        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3297    def __init__(
3298        self,
3299        id=None,
3300        name=None,
3301        tags=None,
3302        vault_uri=None,
3303    ):
3304        self.id = id if id is not None else ''
3305        '''
3306         Unique identifier of the SecretStore.
3307        '''
3308        self.name = name if name is not None else ''
3309        '''
3310         Unique human-readable name of the SecretStore.
3311        '''
3312        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3313        '''
3314         Tags is a map of key, value pairs.
3315        '''
3316        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3326    def to_dict(self):
3327        return {
3328            'id': self.id,
3329            'name': self.name,
3330            'tags': self.tags,
3331            'vault_uri': self.vault_uri,
3332        }
@classmethod
def from_dict(cls, d)
3334    @classmethod
3335    def from_dict(cls, d):
3336        return cls(
3337            id=d.get('id'),
3338            name=d.get('name'),
3339            tags=d.get('tags'),
3340            vault_uri=d.get('vault_uri'),
3341        )
class BigQuery:
3344class BigQuery:
3345    __slots__ = [
3346        'bind_interface',
3347        'egress_filter',
3348        'endpoint',
3349        'healthy',
3350        'id',
3351        'name',
3352        'port_override',
3353        'private_key',
3354        'project',
3355        'secret_store_id',
3356        'tags',
3357        'username',
3358    ]
3359
3360    def __init__(
3361        self,
3362        bind_interface=None,
3363        egress_filter=None,
3364        endpoint=None,
3365        healthy=None,
3366        id=None,
3367        name=None,
3368        port_override=None,
3369        private_key=None,
3370        project=None,
3371        secret_store_id=None,
3372        tags=None,
3373        username=None,
3374    ):
3375        self.bind_interface = bind_interface if bind_interface is not None else ''
3376        '''
3377         Bind interface
3378        '''
3379        self.egress_filter = egress_filter if egress_filter is not None else ''
3380        '''
3381         A filter applied to the routing logic to pin datasource to nodes.
3382        '''
3383        self.endpoint = endpoint if endpoint is not None else ''
3384        self.healthy = healthy if healthy is not None else False
3385        '''
3386         True if the datasource is reachable and the credentials are valid.
3387        '''
3388        self.id = id if id is not None else ''
3389        '''
3390         Unique identifier of the Resource.
3391        '''
3392        self.name = name if name is not None else ''
3393        '''
3394         Unique human-readable name of the Resource.
3395        '''
3396        self.port_override = port_override if port_override is not None else 0
3397        self.private_key = private_key if private_key is not None else ''
3398        self.project = project if project is not None else ''
3399        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3400        '''
3401         ID of the secret store containing credentials for this resource, if any.
3402        '''
3403        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3404        '''
3405         Tags is a map of key, value pairs.
3406        '''
3407        self.username = username if username is not None else ''
3408
3409    def __repr__(self):
3410        return '<sdm.BigQuery ' + \
3411            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3412            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3413            'endpoint: ' + repr(self.endpoint) + ' ' +\
3414            'healthy: ' + repr(self.healthy) + ' ' +\
3415            'id: ' + repr(self.id) + ' ' +\
3416            'name: ' + repr(self.name) + ' ' +\
3417            'port_override: ' + repr(self.port_override) + ' ' +\
3418            'private_key: ' + repr(self.private_key) + ' ' +\
3419            'project: ' + repr(self.project) + ' ' +\
3420            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3421            'tags: ' + repr(self.tags) + ' ' +\
3422            'username: ' + repr(self.username) + ' ' +\
3423            '>'
3424
3425    def to_dict(self):
3426        return {
3427            'bind_interface': self.bind_interface,
3428            'egress_filter': self.egress_filter,
3429            'endpoint': self.endpoint,
3430            'healthy': self.healthy,
3431            'id': self.id,
3432            'name': self.name,
3433            'port_override': self.port_override,
3434            'private_key': self.private_key,
3435            'project': self.project,
3436            'secret_store_id': self.secret_store_id,
3437            'tags': self.tags,
3438            'username': self.username,
3439        }
3440
3441    @classmethod
3442    def from_dict(cls, d):
3443        return cls(
3444            bind_interface=d.get('bind_interface'),
3445            egress_filter=d.get('egress_filter'),
3446            endpoint=d.get('endpoint'),
3447            healthy=d.get('healthy'),
3448            id=d.get('id'),
3449            name=d.get('name'),
3450            port_override=d.get('port_override'),
3451            private_key=d.get('private_key'),
3452            project=d.get('project'),
3453            secret_store_id=d.get('secret_store_id'),
3454            tags=d.get('tags'),
3455            username=d.get('username'),
3456        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3360    def __init__(
3361        self,
3362        bind_interface=None,
3363        egress_filter=None,
3364        endpoint=None,
3365        healthy=None,
3366        id=None,
3367        name=None,
3368        port_override=None,
3369        private_key=None,
3370        project=None,
3371        secret_store_id=None,
3372        tags=None,
3373        username=None,
3374    ):
3375        self.bind_interface = bind_interface if bind_interface is not None else ''
3376        '''
3377         Bind interface
3378        '''
3379        self.egress_filter = egress_filter if egress_filter is not None else ''
3380        '''
3381         A filter applied to the routing logic to pin datasource to nodes.
3382        '''
3383        self.endpoint = endpoint if endpoint is not None else ''
3384        self.healthy = healthy if healthy is not None else False
3385        '''
3386         True if the datasource is reachable and the credentials are valid.
3387        '''
3388        self.id = id if id is not None else ''
3389        '''
3390         Unique identifier of the Resource.
3391        '''
3392        self.name = name if name is not None else ''
3393        '''
3394         Unique human-readable name of the Resource.
3395        '''
3396        self.port_override = port_override if port_override is not None else 0
3397        self.private_key = private_key if private_key is not None else ''
3398        self.project = project if project is not None else ''
3399        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3400        '''
3401         ID of the secret store containing credentials for this resource, if any.
3402        '''
3403        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3404        '''
3405         Tags is a map of key, value pairs.
3406        '''
3407        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3425    def to_dict(self):
3426        return {
3427            'bind_interface': self.bind_interface,
3428            'egress_filter': self.egress_filter,
3429            'endpoint': self.endpoint,
3430            'healthy': self.healthy,
3431            'id': self.id,
3432            'name': self.name,
3433            'port_override': self.port_override,
3434            'private_key': self.private_key,
3435            'project': self.project,
3436            'secret_store_id': self.secret_store_id,
3437            'tags': self.tags,
3438            'username': self.username,
3439        }
@classmethod
def from_dict(cls, d)
3441    @classmethod
3442    def from_dict(cls, d):
3443        return cls(
3444            bind_interface=d.get('bind_interface'),
3445            egress_filter=d.get('egress_filter'),
3446            endpoint=d.get('endpoint'),
3447            healthy=d.get('healthy'),
3448            id=d.get('id'),
3449            name=d.get('name'),
3450            port_override=d.get('port_override'),
3451            private_key=d.get('private_key'),
3452            project=d.get('project'),
3453            secret_store_id=d.get('secret_store_id'),
3454            tags=d.get('tags'),
3455            username=d.get('username'),
3456        )
class Cassandra:
3459class Cassandra:
3460    __slots__ = [
3461        'bind_interface',
3462        'egress_filter',
3463        'healthy',
3464        'hostname',
3465        'id',
3466        'name',
3467        'password',
3468        'port',
3469        'port_override',
3470        'secret_store_id',
3471        'tags',
3472        'tls_required',
3473        'username',
3474    ]
3475
3476    def __init__(
3477        self,
3478        bind_interface=None,
3479        egress_filter=None,
3480        healthy=None,
3481        hostname=None,
3482        id=None,
3483        name=None,
3484        password=None,
3485        port=None,
3486        port_override=None,
3487        secret_store_id=None,
3488        tags=None,
3489        tls_required=None,
3490        username=None,
3491    ):
3492        self.bind_interface = bind_interface if bind_interface is not None else ''
3493        '''
3494         Bind interface
3495        '''
3496        self.egress_filter = egress_filter if egress_filter is not None else ''
3497        '''
3498         A filter applied to the routing logic to pin datasource to nodes.
3499        '''
3500        self.healthy = healthy if healthy is not None else False
3501        '''
3502         True if the datasource is reachable and the credentials are valid.
3503        '''
3504        self.hostname = hostname if hostname is not None else ''
3505        self.id = id if id is not None else ''
3506        '''
3507         Unique identifier of the Resource.
3508        '''
3509        self.name = name if name is not None else ''
3510        '''
3511         Unique human-readable name of the Resource.
3512        '''
3513        self.password = password if password is not None else ''
3514        self.port = port if port is not None else 0
3515        self.port_override = port_override if port_override is not None else 0
3516        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3517        '''
3518         ID of the secret store containing credentials for this resource, if any.
3519        '''
3520        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3521        '''
3522         Tags is a map of key, value pairs.
3523        '''
3524        self.tls_required = tls_required if tls_required is not None else False
3525        self.username = username if username is not None else ''
3526
3527    def __repr__(self):
3528        return '<sdm.Cassandra ' + \
3529            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3530            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3531            'healthy: ' + repr(self.healthy) + ' ' +\
3532            'hostname: ' + repr(self.hostname) + ' ' +\
3533            'id: ' + repr(self.id) + ' ' +\
3534            'name: ' + repr(self.name) + ' ' +\
3535            'password: ' + repr(self.password) + ' ' +\
3536            'port: ' + repr(self.port) + ' ' +\
3537            'port_override: ' + repr(self.port_override) + ' ' +\
3538            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3539            'tags: ' + repr(self.tags) + ' ' +\
3540            'tls_required: ' + repr(self.tls_required) + ' ' +\
3541            'username: ' + repr(self.username) + ' ' +\
3542            '>'
3543
3544    def to_dict(self):
3545        return {
3546            'bind_interface': self.bind_interface,
3547            'egress_filter': self.egress_filter,
3548            'healthy': self.healthy,
3549            'hostname': self.hostname,
3550            'id': self.id,
3551            'name': self.name,
3552            'password': self.password,
3553            'port': self.port,
3554            'port_override': self.port_override,
3555            'secret_store_id': self.secret_store_id,
3556            'tags': self.tags,
3557            'tls_required': self.tls_required,
3558            'username': self.username,
3559        }
3560
3561    @classmethod
3562    def from_dict(cls, d):
3563        return cls(
3564            bind_interface=d.get('bind_interface'),
3565            egress_filter=d.get('egress_filter'),
3566            healthy=d.get('healthy'),
3567            hostname=d.get('hostname'),
3568            id=d.get('id'),
3569            name=d.get('name'),
3570            password=d.get('password'),
3571            port=d.get('port'),
3572            port_override=d.get('port_override'),
3573            secret_store_id=d.get('secret_store_id'),
3574            tags=d.get('tags'),
3575            tls_required=d.get('tls_required'),
3576            username=d.get('username'),
3577        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3476    def __init__(
3477        self,
3478        bind_interface=None,
3479        egress_filter=None,
3480        healthy=None,
3481        hostname=None,
3482        id=None,
3483        name=None,
3484        password=None,
3485        port=None,
3486        port_override=None,
3487        secret_store_id=None,
3488        tags=None,
3489        tls_required=None,
3490        username=None,
3491    ):
3492        self.bind_interface = bind_interface if bind_interface is not None else ''
3493        '''
3494         Bind interface
3495        '''
3496        self.egress_filter = egress_filter if egress_filter is not None else ''
3497        '''
3498         A filter applied to the routing logic to pin datasource to nodes.
3499        '''
3500        self.healthy = healthy if healthy is not None else False
3501        '''
3502         True if the datasource is reachable and the credentials are valid.
3503        '''
3504        self.hostname = hostname if hostname is not None else ''
3505        self.id = id if id is not None else ''
3506        '''
3507         Unique identifier of the Resource.
3508        '''
3509        self.name = name if name is not None else ''
3510        '''
3511         Unique human-readable name of the Resource.
3512        '''
3513        self.password = password if password is not None else ''
3514        self.port = port if port is not None else 0
3515        self.port_override = port_override if port_override is not None else 0
3516        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3517        '''
3518         ID of the secret store containing credentials for this resource, if any.
3519        '''
3520        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3521        '''
3522         Tags is a map of key, value pairs.
3523        '''
3524        self.tls_required = tls_required if tls_required is not None else False
3525        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3544    def to_dict(self):
3545        return {
3546            'bind_interface': self.bind_interface,
3547            'egress_filter': self.egress_filter,
3548            'healthy': self.healthy,
3549            'hostname': self.hostname,
3550            'id': self.id,
3551            'name': self.name,
3552            'password': self.password,
3553            'port': self.port,
3554            'port_override': self.port_override,
3555            'secret_store_id': self.secret_store_id,
3556            'tags': self.tags,
3557            'tls_required': self.tls_required,
3558            'username': self.username,
3559        }
@classmethod
def from_dict(cls, d)
3561    @classmethod
3562    def from_dict(cls, d):
3563        return cls(
3564            bind_interface=d.get('bind_interface'),
3565            egress_filter=d.get('egress_filter'),
3566            healthy=d.get('healthy'),
3567            hostname=d.get('hostname'),
3568            id=d.get('id'),
3569            name=d.get('name'),
3570            password=d.get('password'),
3571            port=d.get('port'),
3572            port_override=d.get('port_override'),
3573            secret_store_id=d.get('secret_store_id'),
3574            tags=d.get('tags'),
3575            tls_required=d.get('tls_required'),
3576            username=d.get('username'),
3577        )
class Citus:
3580class Citus:
3581    __slots__ = [
3582        'bind_interface',
3583        'database',
3584        'egress_filter',
3585        'healthy',
3586        'hostname',
3587        'id',
3588        'name',
3589        'override_database',
3590        'password',
3591        'port',
3592        'port_override',
3593        'secret_store_id',
3594        'tags',
3595        'username',
3596    ]
3597
3598    def __init__(
3599        self,
3600        bind_interface=None,
3601        database=None,
3602        egress_filter=None,
3603        healthy=None,
3604        hostname=None,
3605        id=None,
3606        name=None,
3607        override_database=None,
3608        password=None,
3609        port=None,
3610        port_override=None,
3611        secret_store_id=None,
3612        tags=None,
3613        username=None,
3614    ):
3615        self.bind_interface = bind_interface if bind_interface is not None else ''
3616        '''
3617         Bind interface
3618        '''
3619        self.database = database if database is not None else ''
3620        self.egress_filter = egress_filter if egress_filter is not None else ''
3621        '''
3622         A filter applied to the routing logic to pin datasource to nodes.
3623        '''
3624        self.healthy = healthy if healthy is not None else False
3625        '''
3626         True if the datasource is reachable and the credentials are valid.
3627        '''
3628        self.hostname = hostname if hostname is not None else ''
3629        self.id = id if id is not None else ''
3630        '''
3631         Unique identifier of the Resource.
3632        '''
3633        self.name = name if name is not None else ''
3634        '''
3635         Unique human-readable name of the Resource.
3636        '''
3637        self.override_database = override_database if override_database is not None else False
3638        self.password = password if password is not None else ''
3639        self.port = port if port is not None else 0
3640        self.port_override = port_override if port_override is not None else 0
3641        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3642        '''
3643         ID of the secret store containing credentials for this resource, if any.
3644        '''
3645        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3646        '''
3647         Tags is a map of key, value pairs.
3648        '''
3649        self.username = username if username is not None else ''
3650
3651    def __repr__(self):
3652        return '<sdm.Citus ' + \
3653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3654            'database: ' + repr(self.database) + ' ' +\
3655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3656            'healthy: ' + repr(self.healthy) + ' ' +\
3657            'hostname: ' + repr(self.hostname) + ' ' +\
3658            'id: ' + repr(self.id) + ' ' +\
3659            'name: ' + repr(self.name) + ' ' +\
3660            'override_database: ' + repr(self.override_database) + ' ' +\
3661            'password: ' + repr(self.password) + ' ' +\
3662            'port: ' + repr(self.port) + ' ' +\
3663            'port_override: ' + repr(self.port_override) + ' ' +\
3664            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3665            'tags: ' + repr(self.tags) + ' ' +\
3666            'username: ' + repr(self.username) + ' ' +\
3667            '>'
3668
3669    def to_dict(self):
3670        return {
3671            'bind_interface': self.bind_interface,
3672            'database': self.database,
3673            'egress_filter': self.egress_filter,
3674            'healthy': self.healthy,
3675            'hostname': self.hostname,
3676            'id': self.id,
3677            'name': self.name,
3678            'override_database': self.override_database,
3679            'password': self.password,
3680            'port': self.port,
3681            'port_override': self.port_override,
3682            'secret_store_id': self.secret_store_id,
3683            'tags': self.tags,
3684            'username': self.username,
3685        }
3686
3687    @classmethod
3688    def from_dict(cls, d):
3689        return cls(
3690            bind_interface=d.get('bind_interface'),
3691            database=d.get('database'),
3692            egress_filter=d.get('egress_filter'),
3693            healthy=d.get('healthy'),
3694            hostname=d.get('hostname'),
3695            id=d.get('id'),
3696            name=d.get('name'),
3697            override_database=d.get('override_database'),
3698            password=d.get('password'),
3699            port=d.get('port'),
3700            port_override=d.get('port_override'),
3701            secret_store_id=d.get('secret_store_id'),
3702            tags=d.get('tags'),
3703            username=d.get('username'),
3704        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3598    def __init__(
3599        self,
3600        bind_interface=None,
3601        database=None,
3602        egress_filter=None,
3603        healthy=None,
3604        hostname=None,
3605        id=None,
3606        name=None,
3607        override_database=None,
3608        password=None,
3609        port=None,
3610        port_override=None,
3611        secret_store_id=None,
3612        tags=None,
3613        username=None,
3614    ):
3615        self.bind_interface = bind_interface if bind_interface is not None else ''
3616        '''
3617         Bind interface
3618        '''
3619        self.database = database if database is not None else ''
3620        self.egress_filter = egress_filter if egress_filter is not None else ''
3621        '''
3622         A filter applied to the routing logic to pin datasource to nodes.
3623        '''
3624        self.healthy = healthy if healthy is not None else False
3625        '''
3626         True if the datasource is reachable and the credentials are valid.
3627        '''
3628        self.hostname = hostname if hostname is not None else ''
3629        self.id = id if id is not None else ''
3630        '''
3631         Unique identifier of the Resource.
3632        '''
3633        self.name = name if name is not None else ''
3634        '''
3635         Unique human-readable name of the Resource.
3636        '''
3637        self.override_database = override_database if override_database is not None else False
3638        self.password = password if password is not None else ''
3639        self.port = port if port is not None else 0
3640        self.port_override = port_override if port_override is not None else 0
3641        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3642        '''
3643         ID of the secret store containing credentials for this resource, if any.
3644        '''
3645        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3646        '''
3647         Tags is a map of key, value pairs.
3648        '''
3649        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3669    def to_dict(self):
3670        return {
3671            'bind_interface': self.bind_interface,
3672            'database': self.database,
3673            'egress_filter': self.egress_filter,
3674            'healthy': self.healthy,
3675            'hostname': self.hostname,
3676            'id': self.id,
3677            'name': self.name,
3678            'override_database': self.override_database,
3679            'password': self.password,
3680            'port': self.port,
3681            'port_override': self.port_override,
3682            'secret_store_id': self.secret_store_id,
3683            'tags': self.tags,
3684            'username': self.username,
3685        }
@classmethod
def from_dict(cls, d)
3687    @classmethod
3688    def from_dict(cls, d):
3689        return cls(
3690            bind_interface=d.get('bind_interface'),
3691            database=d.get('database'),
3692            egress_filter=d.get('egress_filter'),
3693            healthy=d.get('healthy'),
3694            hostname=d.get('hostname'),
3695            id=d.get('id'),
3696            name=d.get('name'),
3697            override_database=d.get('override_database'),
3698            password=d.get('password'),
3699            port=d.get('port'),
3700            port_override=d.get('port_override'),
3701            secret_store_id=d.get('secret_store_id'),
3702            tags=d.get('tags'),
3703            username=d.get('username'),
3704        )
class Clustrix:
3707class Clustrix:
3708    __slots__ = [
3709        'bind_interface',
3710        'database',
3711        'egress_filter',
3712        'healthy',
3713        'hostname',
3714        'id',
3715        'name',
3716        'password',
3717        'port',
3718        'port_override',
3719        'secret_store_id',
3720        'tags',
3721        'username',
3722    ]
3723
3724    def __init__(
3725        self,
3726        bind_interface=None,
3727        database=None,
3728        egress_filter=None,
3729        healthy=None,
3730        hostname=None,
3731        id=None,
3732        name=None,
3733        password=None,
3734        port=None,
3735        port_override=None,
3736        secret_store_id=None,
3737        tags=None,
3738        username=None,
3739    ):
3740        self.bind_interface = bind_interface if bind_interface is not None else ''
3741        '''
3742         Bind interface
3743        '''
3744        self.database = database if database is not None else ''
3745        self.egress_filter = egress_filter if egress_filter is not None else ''
3746        '''
3747         A filter applied to the routing logic to pin datasource to nodes.
3748        '''
3749        self.healthy = healthy if healthy is not None else False
3750        '''
3751         True if the datasource is reachable and the credentials are valid.
3752        '''
3753        self.hostname = hostname if hostname is not None else ''
3754        self.id = id if id is not None else ''
3755        '''
3756         Unique identifier of the Resource.
3757        '''
3758        self.name = name if name is not None else ''
3759        '''
3760         Unique human-readable name of the Resource.
3761        '''
3762        self.password = password if password is not None else ''
3763        self.port = port if port is not None else 0
3764        self.port_override = port_override if port_override is not None else 0
3765        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3766        '''
3767         ID of the secret store containing credentials for this resource, if any.
3768        '''
3769        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3770        '''
3771         Tags is a map of key, value pairs.
3772        '''
3773        self.username = username if username is not None else ''
3774
3775    def __repr__(self):
3776        return '<sdm.Clustrix ' + \
3777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3778            'database: ' + repr(self.database) + ' ' +\
3779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3780            'healthy: ' + repr(self.healthy) + ' ' +\
3781            'hostname: ' + repr(self.hostname) + ' ' +\
3782            'id: ' + repr(self.id) + ' ' +\
3783            'name: ' + repr(self.name) + ' ' +\
3784            'password: ' + repr(self.password) + ' ' +\
3785            'port: ' + repr(self.port) + ' ' +\
3786            'port_override: ' + repr(self.port_override) + ' ' +\
3787            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3788            'tags: ' + repr(self.tags) + ' ' +\
3789            'username: ' + repr(self.username) + ' ' +\
3790            '>'
3791
3792    def to_dict(self):
3793        return {
3794            'bind_interface': self.bind_interface,
3795            'database': self.database,
3796            'egress_filter': self.egress_filter,
3797            'healthy': self.healthy,
3798            'hostname': self.hostname,
3799            'id': self.id,
3800            'name': self.name,
3801            'password': self.password,
3802            'port': self.port,
3803            'port_override': self.port_override,
3804            'secret_store_id': self.secret_store_id,
3805            'tags': self.tags,
3806            'username': self.username,
3807        }
3808
3809    @classmethod
3810    def from_dict(cls, d):
3811        return cls(
3812            bind_interface=d.get('bind_interface'),
3813            database=d.get('database'),
3814            egress_filter=d.get('egress_filter'),
3815            healthy=d.get('healthy'),
3816            hostname=d.get('hostname'),
3817            id=d.get('id'),
3818            name=d.get('name'),
3819            password=d.get('password'),
3820            port=d.get('port'),
3821            port_override=d.get('port_override'),
3822            secret_store_id=d.get('secret_store_id'),
3823            tags=d.get('tags'),
3824            username=d.get('username'),
3825        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3724    def __init__(
3725        self,
3726        bind_interface=None,
3727        database=None,
3728        egress_filter=None,
3729        healthy=None,
3730        hostname=None,
3731        id=None,
3732        name=None,
3733        password=None,
3734        port=None,
3735        port_override=None,
3736        secret_store_id=None,
3737        tags=None,
3738        username=None,
3739    ):
3740        self.bind_interface = bind_interface if bind_interface is not None else ''
3741        '''
3742         Bind interface
3743        '''
3744        self.database = database if database is not None else ''
3745        self.egress_filter = egress_filter if egress_filter is not None else ''
3746        '''
3747         A filter applied to the routing logic to pin datasource to nodes.
3748        '''
3749        self.healthy = healthy if healthy is not None else False
3750        '''
3751         True if the datasource is reachable and the credentials are valid.
3752        '''
3753        self.hostname = hostname if hostname is not None else ''
3754        self.id = id if id is not None else ''
3755        '''
3756         Unique identifier of the Resource.
3757        '''
3758        self.name = name if name is not None else ''
3759        '''
3760         Unique human-readable name of the Resource.
3761        '''
3762        self.password = password if password is not None else ''
3763        self.port = port if port is not None else 0
3764        self.port_override = port_override if port_override is not None else 0
3765        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3766        '''
3767         ID of the secret store containing credentials for this resource, if any.
3768        '''
3769        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3770        '''
3771         Tags is a map of key, value pairs.
3772        '''
3773        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3792    def to_dict(self):
3793        return {
3794            'bind_interface': self.bind_interface,
3795            'database': self.database,
3796            'egress_filter': self.egress_filter,
3797            'healthy': self.healthy,
3798            'hostname': self.hostname,
3799            'id': self.id,
3800            'name': self.name,
3801            'password': self.password,
3802            'port': self.port,
3803            'port_override': self.port_override,
3804            'secret_store_id': self.secret_store_id,
3805            'tags': self.tags,
3806            'username': self.username,
3807        }
@classmethod
def from_dict(cls, d)
3809    @classmethod
3810    def from_dict(cls, d):
3811        return cls(
3812            bind_interface=d.get('bind_interface'),
3813            database=d.get('database'),
3814            egress_filter=d.get('egress_filter'),
3815            healthy=d.get('healthy'),
3816            hostname=d.get('hostname'),
3817            id=d.get('id'),
3818            name=d.get('name'),
3819            password=d.get('password'),
3820            port=d.get('port'),
3821            port_override=d.get('port_override'),
3822            secret_store_id=d.get('secret_store_id'),
3823            tags=d.get('tags'),
3824            username=d.get('username'),
3825        )
class Cockroach:
3828class Cockroach:
3829    __slots__ = [
3830        'bind_interface',
3831        'database',
3832        'egress_filter',
3833        'healthy',
3834        'hostname',
3835        'id',
3836        'name',
3837        'override_database',
3838        'password',
3839        'port',
3840        'port_override',
3841        'secret_store_id',
3842        'tags',
3843        'username',
3844    ]
3845
3846    def __init__(
3847        self,
3848        bind_interface=None,
3849        database=None,
3850        egress_filter=None,
3851        healthy=None,
3852        hostname=None,
3853        id=None,
3854        name=None,
3855        override_database=None,
3856        password=None,
3857        port=None,
3858        port_override=None,
3859        secret_store_id=None,
3860        tags=None,
3861        username=None,
3862    ):
3863        self.bind_interface = bind_interface if bind_interface is not None else ''
3864        '''
3865         Bind interface
3866        '''
3867        self.database = database if database is not None else ''
3868        self.egress_filter = egress_filter if egress_filter is not None else ''
3869        '''
3870         A filter applied to the routing logic to pin datasource to nodes.
3871        '''
3872        self.healthy = healthy if healthy is not None else False
3873        '''
3874         True if the datasource is reachable and the credentials are valid.
3875        '''
3876        self.hostname = hostname if hostname is not None else ''
3877        self.id = id if id is not None else ''
3878        '''
3879         Unique identifier of the Resource.
3880        '''
3881        self.name = name if name is not None else ''
3882        '''
3883         Unique human-readable name of the Resource.
3884        '''
3885        self.override_database = override_database if override_database is not None else False
3886        self.password = password if password is not None else ''
3887        self.port = port if port is not None else 0
3888        self.port_override = port_override if port_override is not None else 0
3889        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3890        '''
3891         ID of the secret store containing credentials for this resource, if any.
3892        '''
3893        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3894        '''
3895         Tags is a map of key, value pairs.
3896        '''
3897        self.username = username if username is not None else ''
3898
3899    def __repr__(self):
3900        return '<sdm.Cockroach ' + \
3901            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3902            'database: ' + repr(self.database) + ' ' +\
3903            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3904            'healthy: ' + repr(self.healthy) + ' ' +\
3905            'hostname: ' + repr(self.hostname) + ' ' +\
3906            'id: ' + repr(self.id) + ' ' +\
3907            'name: ' + repr(self.name) + ' ' +\
3908            'override_database: ' + repr(self.override_database) + ' ' +\
3909            'password: ' + repr(self.password) + ' ' +\
3910            'port: ' + repr(self.port) + ' ' +\
3911            'port_override: ' + repr(self.port_override) + ' ' +\
3912            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3913            'tags: ' + repr(self.tags) + ' ' +\
3914            'username: ' + repr(self.username) + ' ' +\
3915            '>'
3916
3917    def to_dict(self):
3918        return {
3919            'bind_interface': self.bind_interface,
3920            'database': self.database,
3921            'egress_filter': self.egress_filter,
3922            'healthy': self.healthy,
3923            'hostname': self.hostname,
3924            'id': self.id,
3925            'name': self.name,
3926            'override_database': self.override_database,
3927            'password': self.password,
3928            'port': self.port,
3929            'port_override': self.port_override,
3930            'secret_store_id': self.secret_store_id,
3931            'tags': self.tags,
3932            'username': self.username,
3933        }
3934
3935    @classmethod
3936    def from_dict(cls, d):
3937        return cls(
3938            bind_interface=d.get('bind_interface'),
3939            database=d.get('database'),
3940            egress_filter=d.get('egress_filter'),
3941            healthy=d.get('healthy'),
3942            hostname=d.get('hostname'),
3943            id=d.get('id'),
3944            name=d.get('name'),
3945            override_database=d.get('override_database'),
3946            password=d.get('password'),
3947            port=d.get('port'),
3948            port_override=d.get('port_override'),
3949            secret_store_id=d.get('secret_store_id'),
3950            tags=d.get('tags'),
3951            username=d.get('username'),
3952        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3846    def __init__(
3847        self,
3848        bind_interface=None,
3849        database=None,
3850        egress_filter=None,
3851        healthy=None,
3852        hostname=None,
3853        id=None,
3854        name=None,
3855        override_database=None,
3856        password=None,
3857        port=None,
3858        port_override=None,
3859        secret_store_id=None,
3860        tags=None,
3861        username=None,
3862    ):
3863        self.bind_interface = bind_interface if bind_interface is not None else ''
3864        '''
3865         Bind interface
3866        '''
3867        self.database = database if database is not None else ''
3868        self.egress_filter = egress_filter if egress_filter is not None else ''
3869        '''
3870         A filter applied to the routing logic to pin datasource to nodes.
3871        '''
3872        self.healthy = healthy if healthy is not None else False
3873        '''
3874         True if the datasource is reachable and the credentials are valid.
3875        '''
3876        self.hostname = hostname if hostname is not None else ''
3877        self.id = id if id is not None else ''
3878        '''
3879         Unique identifier of the Resource.
3880        '''
3881        self.name = name if name is not None else ''
3882        '''
3883         Unique human-readable name of the Resource.
3884        '''
3885        self.override_database = override_database if override_database is not None else False
3886        self.password = password if password is not None else ''
3887        self.port = port if port is not None else 0
3888        self.port_override = port_override if port_override is not None else 0
3889        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3890        '''
3891         ID of the secret store containing credentials for this resource, if any.
3892        '''
3893        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3894        '''
3895         Tags is a map of key, value pairs.
3896        '''
3897        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3917    def to_dict(self):
3918        return {
3919            'bind_interface': self.bind_interface,
3920            'database': self.database,
3921            'egress_filter': self.egress_filter,
3922            'healthy': self.healthy,
3923            'hostname': self.hostname,
3924            'id': self.id,
3925            'name': self.name,
3926            'override_database': self.override_database,
3927            'password': self.password,
3928            'port': self.port,
3929            'port_override': self.port_override,
3930            'secret_store_id': self.secret_store_id,
3931            'tags': self.tags,
3932            'username': self.username,
3933        }
@classmethod
def from_dict(cls, d)
3935    @classmethod
3936    def from_dict(cls, d):
3937        return cls(
3938            bind_interface=d.get('bind_interface'),
3939            database=d.get('database'),
3940            egress_filter=d.get('egress_filter'),
3941            healthy=d.get('healthy'),
3942            hostname=d.get('hostname'),
3943            id=d.get('id'),
3944            name=d.get('name'),
3945            override_database=d.get('override_database'),
3946            password=d.get('password'),
3947            port=d.get('port'),
3948            port_override=d.get('port_override'),
3949            secret_store_id=d.get('secret_store_id'),
3950            tags=d.get('tags'),
3951            username=d.get('username'),
3952        )
class ControlPanelGetSSHCAPublicKeyResponse:
3955class ControlPanelGetSSHCAPublicKeyResponse:
3956    '''
3957         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3958     organization's SSH Certificate Authority public key.
3959    '''
3960    __slots__ = [
3961        'meta',
3962        'public_key',
3963        'rate_limit',
3964    ]
3965
3966    def __init__(
3967        self,
3968        meta=None,
3969        public_key=None,
3970        rate_limit=None,
3971    ):
3972        self.meta = meta if meta is not None else None
3973        '''
3974         Reserved for future use.
3975        '''
3976        self.public_key = public_key if public_key is not None else ''
3977        '''
3978         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3979         key format.
3980        '''
3981        self.rate_limit = rate_limit if rate_limit is not None else None
3982        '''
3983         Rate limit information.
3984        '''
3985
3986    def __repr__(self):
3987        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3988            'meta: ' + repr(self.meta) + ' ' +\
3989            'public_key: ' + repr(self.public_key) + ' ' +\
3990            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3991            '>'
3992
3993    def to_dict(self):
3994        return {
3995            'meta': self.meta,
3996            'public_key': self.public_key,
3997            'rate_limit': self.rate_limit,
3998        }
3999
4000    @classmethod
4001    def from_dict(cls, d):
4002        return cls(
4003            meta=d.get('meta'),
4004            public_key=d.get('public_key'),
4005            rate_limit=d.get('rate_limit'),
4006        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3966    def __init__(
3967        self,
3968        meta=None,
3969        public_key=None,
3970        rate_limit=None,
3971    ):
3972        self.meta = meta if meta is not None else None
3973        '''
3974         Reserved for future use.
3975        '''
3976        self.public_key = public_key if public_key is not None else ''
3977        '''
3978         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3979         key format.
3980        '''
3981        self.rate_limit = rate_limit if rate_limit is not None else None
3982        '''
3983         Rate limit information.
3984        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3993    def to_dict(self):
3994        return {
3995            'meta': self.meta,
3996            'public_key': self.public_key,
3997            'rate_limit': self.rate_limit,
3998        }
@classmethod
def from_dict(cls, d)
4000    @classmethod
4001    def from_dict(cls, d):
4002        return cls(
4003            meta=d.get('meta'),
4004            public_key=d.get('public_key'),
4005            rate_limit=d.get('rate_limit'),
4006        )
class ControlPanelVerifyJWTResponse:
4009class ControlPanelVerifyJWTResponse:
4010    '''
4011         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
4012    '''
4013    __slots__ = [
4014        'meta',
4015        'rate_limit',
4016        'valid',
4017    ]
4018
4019    def __init__(
4020        self,
4021        meta=None,
4022        rate_limit=None,
4023        valid=None,
4024    ):
4025        self.meta = meta if meta is not None else None
4026        '''
4027         Reserved for future use.
4028        '''
4029        self.rate_limit = rate_limit if rate_limit is not None else None
4030        '''
4031         Rate limit information.
4032        '''
4033        self.valid = valid if valid is not None else False
4034        '''
4035         Reports if the given token is valid.
4036        '''
4037
4038    def __repr__(self):
4039        return '<sdm.ControlPanelVerifyJWTResponse ' + \
4040            'meta: ' + repr(self.meta) + ' ' +\
4041            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
4042            'valid: ' + repr(self.valid) + ' ' +\
4043            '>'
4044
4045    def to_dict(self):
4046        return {
4047            'meta': self.meta,
4048            'rate_limit': self.rate_limit,
4049            'valid': self.valid,
4050        }
4051
4052    @classmethod
4053    def from_dict(cls, d):
4054        return cls(
4055            meta=d.get('meta'),
4056            rate_limit=d.get('rate_limit'),
4057            valid=d.get('valid'),
4058        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
4019    def __init__(
4020        self,
4021        meta=None,
4022        rate_limit=None,
4023        valid=None,
4024    ):
4025        self.meta = meta if meta is not None else None
4026        '''
4027         Reserved for future use.
4028        '''
4029        self.rate_limit = rate_limit if rate_limit is not None else None
4030        '''
4031         Rate limit information.
4032        '''
4033        self.valid = valid if valid is not None else False
4034        '''
4035         Reports if the given token is valid.
4036        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
4045    def to_dict(self):
4046        return {
4047            'meta': self.meta,
4048            'rate_limit': self.rate_limit,
4049            'valid': self.valid,
4050        }
@classmethod
def from_dict(cls, d)
4052    @classmethod
4053    def from_dict(cls, d):
4054        return cls(
4055            meta=d.get('meta'),
4056            rate_limit=d.get('rate_limit'),
4057            valid=d.get('valid'),
4058        )
class CreateResponseMetadata:
4061class CreateResponseMetadata:
4062    '''
4063         CreateResponseMetadata is reserved for future use.
4064    '''
4065    __slots__ = []
4066
4067    def __init__(self, ):
4068        pass
4069
4070    def __repr__(self):
4071        return '<sdm.CreateResponseMetadata ' + \
4072            '>'
4073
4074    def to_dict(self):
4075        return {}
4076
4077    @classmethod
4078    def from_dict(cls, d):
4079        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
4067    def __init__(self, ):
4068        pass
def to_dict(self)
4074    def to_dict(self):
4075        return {}
@classmethod
def from_dict(cls, d)
4077    @classmethod
4078    def from_dict(cls, d):
4079        return cls()
class CyberarkConjurStore:
4082class CyberarkConjurStore:
4083    __slots__ = [
4084        'appurl',
4085        'id',
4086        'name',
4087        'tags',
4088    ]
4089
4090    def __init__(
4091        self,
4092        appurl=None,
4093        id=None,
4094        name=None,
4095        tags=None,
4096    ):
4097        self.appurl = appurl if appurl is not None else ''
4098        self.id = id if id is not None else ''
4099        '''
4100         Unique identifier of the SecretStore.
4101        '''
4102        self.name = name if name is not None else ''
4103        '''
4104         Unique human-readable name of the SecretStore.
4105        '''
4106        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4107        '''
4108         Tags is a map of key, value pairs.
4109        '''
4110
4111    def __repr__(self):
4112        return '<sdm.CyberarkConjurStore ' + \
4113            'appurl: ' + repr(self.appurl) + ' ' +\
4114            'id: ' + repr(self.id) + ' ' +\
4115            'name: ' + repr(self.name) + ' ' +\
4116            'tags: ' + repr(self.tags) + ' ' +\
4117            '>'
4118
4119    def to_dict(self):
4120        return {
4121            'appurl': self.appurl,
4122            'id': self.id,
4123            'name': self.name,
4124            'tags': self.tags,
4125        }
4126
4127    @classmethod
4128    def from_dict(cls, d):
4129        return cls(
4130            appurl=d.get('appurl'),
4131            id=d.get('id'),
4132            name=d.get('name'),
4133            tags=d.get('tags'),
4134        )
CyberarkConjurStore(appurl=None, id=None, name=None, tags=None)
4090    def __init__(
4091        self,
4092        appurl=None,
4093        id=None,
4094        name=None,
4095        tags=None,
4096    ):
4097        self.appurl = appurl if appurl is not None else ''
4098        self.id = id if id is not None else ''
4099        '''
4100         Unique identifier of the SecretStore.
4101        '''
4102        self.name = name if name is not None else ''
4103        '''
4104         Unique human-readable name of the SecretStore.
4105        '''
4106        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4107        '''
4108         Tags is a map of key, value pairs.
4109        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4119    def to_dict(self):
4120        return {
4121            'appurl': self.appurl,
4122            'id': self.id,
4123            'name': self.name,
4124            'tags': self.tags,
4125        }
@classmethod
def from_dict(cls, d)
4127    @classmethod
4128    def from_dict(cls, d):
4129        return cls(
4130            appurl=d.get('appurl'),
4131            id=d.get('id'),
4132            name=d.get('name'),
4133            tags=d.get('tags'),
4134        )
class CyberarkPAMExperimentalStore:
4137class CyberarkPAMExperimentalStore:
4138    '''
4139    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
4140    without a major version bump.
4141    '''
4142    __slots__ = [
4143        'appurl',
4144        'id',
4145        'name',
4146        'tags',
4147    ]
4148
4149    def __init__(
4150        self,
4151        appurl=None,
4152        id=None,
4153        name=None,
4154        tags=None,
4155    ):
4156        self.appurl = appurl if appurl is not None else ''
4157        self.id = id if id is not None else ''
4158        '''
4159         Unique identifier of the SecretStore.
4160        '''
4161        self.name = name if name is not None else ''
4162        '''
4163         Unique human-readable name of the SecretStore.
4164        '''
4165        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4166        '''
4167         Tags is a map of key, value pairs.
4168        '''
4169
4170    def __repr__(self):
4171        return '<sdm.CyberarkPAMExperimentalStore ' + \
4172            'appurl: ' + repr(self.appurl) + ' ' +\
4173            'id: ' + repr(self.id) + ' ' +\
4174            'name: ' + repr(self.name) + ' ' +\
4175            'tags: ' + repr(self.tags) + ' ' +\
4176            '>'
4177
4178    def to_dict(self):
4179        return {
4180            'appurl': self.appurl,
4181            'id': self.id,
4182            'name': self.name,
4183            'tags': self.tags,
4184        }
4185
4186    @classmethod
4187    def from_dict(cls, d):
4188        return cls(
4189            appurl=d.get('appurl'),
4190            id=d.get('id'),
4191            name=d.get('name'),
4192            tags=d.get('tags'),
4193        )

CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkPAMExperimentalStore(appurl=None, id=None, name=None, tags=None)
4149    def __init__(
4150        self,
4151        appurl=None,
4152        id=None,
4153        name=None,
4154        tags=None,
4155    ):
4156        self.appurl = appurl if appurl is not None else ''
4157        self.id = id if id is not None else ''
4158        '''
4159         Unique identifier of the SecretStore.
4160        '''
4161        self.name = name if name is not None else ''
4162        '''
4163         Unique human-readable name of the SecretStore.
4164        '''
4165        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4166        '''
4167         Tags is a map of key, value pairs.
4168        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4178    def to_dict(self):
4179        return {
4180            'appurl': self.appurl,
4181            'id': self.id,
4182            'name': self.name,
4183            'tags': self.tags,
4184        }
@classmethod
def from_dict(cls, d)
4186    @classmethod
4187    def from_dict(cls, d):
4188        return cls(
4189            appurl=d.get('appurl'),
4190            id=d.get('id'),
4191            name=d.get('name'),
4192            tags=d.get('tags'),
4193        )
class CyberarkPAMStore:
4196class CyberarkPAMStore:
4197    __slots__ = [
4198        'appurl',
4199        'id',
4200        'name',
4201        'tags',
4202    ]
4203
4204    def __init__(
4205        self,
4206        appurl=None,
4207        id=None,
4208        name=None,
4209        tags=None,
4210    ):
4211        self.appurl = appurl if appurl is not None else ''
4212        self.id = id if id is not None else ''
4213        '''
4214         Unique identifier of the SecretStore.
4215        '''
4216        self.name = name if name is not None else ''
4217        '''
4218         Unique human-readable name of the SecretStore.
4219        '''
4220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4221        '''
4222         Tags is a map of key, value pairs.
4223        '''
4224
4225    def __repr__(self):
4226        return '<sdm.CyberarkPAMStore ' + \
4227            'appurl: ' + repr(self.appurl) + ' ' +\
4228            'id: ' + repr(self.id) + ' ' +\
4229            'name: ' + repr(self.name) + ' ' +\
4230            'tags: ' + repr(self.tags) + ' ' +\
4231            '>'
4232
4233    def to_dict(self):
4234        return {
4235            'appurl': self.appurl,
4236            'id': self.id,
4237            'name': self.name,
4238            'tags': self.tags,
4239        }
4240
4241    @classmethod
4242    def from_dict(cls, d):
4243        return cls(
4244            appurl=d.get('appurl'),
4245            id=d.get('id'),
4246            name=d.get('name'),
4247            tags=d.get('tags'),
4248        )
CyberarkPAMStore(appurl=None, id=None, name=None, tags=None)
4204    def __init__(
4205        self,
4206        appurl=None,
4207        id=None,
4208        name=None,
4209        tags=None,
4210    ):
4211        self.appurl = appurl if appurl is not None else ''
4212        self.id = id if id is not None else ''
4213        '''
4214         Unique identifier of the SecretStore.
4215        '''
4216        self.name = name if name is not None else ''
4217        '''
4218         Unique human-readable name of the SecretStore.
4219        '''
4220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4221        '''
4222         Tags is a map of key, value pairs.
4223        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4233    def to_dict(self):
4234        return {
4235            'appurl': self.appurl,
4236            'id': self.id,
4237            'name': self.name,
4238            'tags': self.tags,
4239        }
@classmethod
def from_dict(cls, d)
4241    @classmethod
4242    def from_dict(cls, d):
4243        return cls(
4244            appurl=d.get('appurl'),
4245            id=d.get('id'),
4246            name=d.get('name'),
4247            tags=d.get('tags'),
4248        )
class DB2I:
4251class DB2I:
4252    __slots__ = [
4253        'bind_interface',
4254        'egress_filter',
4255        'healthy',
4256        'hostname',
4257        'id',
4258        'name',
4259        'password',
4260        'port',
4261        'port_override',
4262        'secret_store_id',
4263        'tags',
4264        'tls_required',
4265        'username',
4266    ]
4267
4268    def __init__(
4269        self,
4270        bind_interface=None,
4271        egress_filter=None,
4272        healthy=None,
4273        hostname=None,
4274        id=None,
4275        name=None,
4276        password=None,
4277        port=None,
4278        port_override=None,
4279        secret_store_id=None,
4280        tags=None,
4281        tls_required=None,
4282        username=None,
4283    ):
4284        self.bind_interface = bind_interface if bind_interface is not None else ''
4285        '''
4286         Bind interface
4287        '''
4288        self.egress_filter = egress_filter if egress_filter is not None else ''
4289        '''
4290         A filter applied to the routing logic to pin datasource to nodes.
4291        '''
4292        self.healthy = healthy if healthy is not None else False
4293        '''
4294         True if the datasource is reachable and the credentials are valid.
4295        '''
4296        self.hostname = hostname if hostname is not None else ''
4297        self.id = id if id is not None else ''
4298        '''
4299         Unique identifier of the Resource.
4300        '''
4301        self.name = name if name is not None else ''
4302        '''
4303         Unique human-readable name of the Resource.
4304        '''
4305        self.password = password if password is not None else ''
4306        self.port = port if port is not None else 0
4307        self.port_override = port_override if port_override is not None else 0
4308        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4309        '''
4310         ID of the secret store containing credentials for this resource, if any.
4311        '''
4312        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4313        '''
4314         Tags is a map of key, value pairs.
4315        '''
4316        self.tls_required = tls_required if tls_required is not None else False
4317        self.username = username if username is not None else ''
4318
4319    def __repr__(self):
4320        return '<sdm.DB2I ' + \
4321            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4322            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4323            'healthy: ' + repr(self.healthy) + ' ' +\
4324            'hostname: ' + repr(self.hostname) + ' ' +\
4325            'id: ' + repr(self.id) + ' ' +\
4326            'name: ' + repr(self.name) + ' ' +\
4327            'password: ' + repr(self.password) + ' ' +\
4328            'port: ' + repr(self.port) + ' ' +\
4329            'port_override: ' + repr(self.port_override) + ' ' +\
4330            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4331            'tags: ' + repr(self.tags) + ' ' +\
4332            'tls_required: ' + repr(self.tls_required) + ' ' +\
4333            'username: ' + repr(self.username) + ' ' +\
4334            '>'
4335
4336    def to_dict(self):
4337        return {
4338            'bind_interface': self.bind_interface,
4339            'egress_filter': self.egress_filter,
4340            'healthy': self.healthy,
4341            'hostname': self.hostname,
4342            'id': self.id,
4343            'name': self.name,
4344            'password': self.password,
4345            'port': self.port,
4346            'port_override': self.port_override,
4347            'secret_store_id': self.secret_store_id,
4348            'tags': self.tags,
4349            'tls_required': self.tls_required,
4350            'username': self.username,
4351        }
4352
4353    @classmethod
4354    def from_dict(cls, d):
4355        return cls(
4356            bind_interface=d.get('bind_interface'),
4357            egress_filter=d.get('egress_filter'),
4358            healthy=d.get('healthy'),
4359            hostname=d.get('hostname'),
4360            id=d.get('id'),
4361            name=d.get('name'),
4362            password=d.get('password'),
4363            port=d.get('port'),
4364            port_override=d.get('port_override'),
4365            secret_store_id=d.get('secret_store_id'),
4366            tags=d.get('tags'),
4367            tls_required=d.get('tls_required'),
4368            username=d.get('username'),
4369        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4268    def __init__(
4269        self,
4270        bind_interface=None,
4271        egress_filter=None,
4272        healthy=None,
4273        hostname=None,
4274        id=None,
4275        name=None,
4276        password=None,
4277        port=None,
4278        port_override=None,
4279        secret_store_id=None,
4280        tags=None,
4281        tls_required=None,
4282        username=None,
4283    ):
4284        self.bind_interface = bind_interface if bind_interface is not None else ''
4285        '''
4286         Bind interface
4287        '''
4288        self.egress_filter = egress_filter if egress_filter is not None else ''
4289        '''
4290         A filter applied to the routing logic to pin datasource to nodes.
4291        '''
4292        self.healthy = healthy if healthy is not None else False
4293        '''
4294         True if the datasource is reachable and the credentials are valid.
4295        '''
4296        self.hostname = hostname if hostname is not None else ''
4297        self.id = id if id is not None else ''
4298        '''
4299         Unique identifier of the Resource.
4300        '''
4301        self.name = name if name is not None else ''
4302        '''
4303         Unique human-readable name of the Resource.
4304        '''
4305        self.password = password if password is not None else ''
4306        self.port = port if port is not None else 0
4307        self.port_override = port_override if port_override is not None else 0
4308        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4309        '''
4310         ID of the secret store containing credentials for this resource, if any.
4311        '''
4312        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4313        '''
4314         Tags is a map of key, value pairs.
4315        '''
4316        self.tls_required = tls_required if tls_required is not None else False
4317        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4336    def to_dict(self):
4337        return {
4338            'bind_interface': self.bind_interface,
4339            'egress_filter': self.egress_filter,
4340            'healthy': self.healthy,
4341            'hostname': self.hostname,
4342            'id': self.id,
4343            'name': self.name,
4344            'password': self.password,
4345            'port': self.port,
4346            'port_override': self.port_override,
4347            'secret_store_id': self.secret_store_id,
4348            'tags': self.tags,
4349            'tls_required': self.tls_required,
4350            'username': self.username,
4351        }
@classmethod
def from_dict(cls, d)
4353    @classmethod
4354    def from_dict(cls, d):
4355        return cls(
4356            bind_interface=d.get('bind_interface'),
4357            egress_filter=d.get('egress_filter'),
4358            healthy=d.get('healthy'),
4359            hostname=d.get('hostname'),
4360            id=d.get('id'),
4361            name=d.get('name'),
4362            password=d.get('password'),
4363            port=d.get('port'),
4364            port_override=d.get('port_override'),
4365            secret_store_id=d.get('secret_store_id'),
4366            tags=d.get('tags'),
4367            tls_required=d.get('tls_required'),
4368            username=d.get('username'),
4369        )
class DB2LUW:
4372class DB2LUW:
4373    __slots__ = [
4374        'bind_interface',
4375        'database',
4376        'egress_filter',
4377        'healthy',
4378        'hostname',
4379        'id',
4380        'name',
4381        'password',
4382        'port',
4383        'port_override',
4384        'secret_store_id',
4385        'tags',
4386        'username',
4387    ]
4388
4389    def __init__(
4390        self,
4391        bind_interface=None,
4392        database=None,
4393        egress_filter=None,
4394        healthy=None,
4395        hostname=None,
4396        id=None,
4397        name=None,
4398        password=None,
4399        port=None,
4400        port_override=None,
4401        secret_store_id=None,
4402        tags=None,
4403        username=None,
4404    ):
4405        self.bind_interface = bind_interface if bind_interface is not None else ''
4406        '''
4407         Bind interface
4408        '''
4409        self.database = database if database is not None else ''
4410        self.egress_filter = egress_filter if egress_filter is not None else ''
4411        '''
4412         A filter applied to the routing logic to pin datasource to nodes.
4413        '''
4414        self.healthy = healthy if healthy is not None else False
4415        '''
4416         True if the datasource is reachable and the credentials are valid.
4417        '''
4418        self.hostname = hostname if hostname is not None else ''
4419        self.id = id if id is not None else ''
4420        '''
4421         Unique identifier of the Resource.
4422        '''
4423        self.name = name if name is not None else ''
4424        '''
4425         Unique human-readable name of the Resource.
4426        '''
4427        self.password = password if password is not None else ''
4428        self.port = port if port is not None else 0
4429        self.port_override = port_override if port_override is not None else 0
4430        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4431        '''
4432         ID of the secret store containing credentials for this resource, if any.
4433        '''
4434        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4435        '''
4436         Tags is a map of key, value pairs.
4437        '''
4438        self.username = username if username is not None else ''
4439
4440    def __repr__(self):
4441        return '<sdm.DB2LUW ' + \
4442            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4443            'database: ' + repr(self.database) + ' ' +\
4444            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4445            'healthy: ' + repr(self.healthy) + ' ' +\
4446            'hostname: ' + repr(self.hostname) + ' ' +\
4447            'id: ' + repr(self.id) + ' ' +\
4448            'name: ' + repr(self.name) + ' ' +\
4449            'password: ' + repr(self.password) + ' ' +\
4450            'port: ' + repr(self.port) + ' ' +\
4451            'port_override: ' + repr(self.port_override) + ' ' +\
4452            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4453            'tags: ' + repr(self.tags) + ' ' +\
4454            'username: ' + repr(self.username) + ' ' +\
4455            '>'
4456
4457    def to_dict(self):
4458        return {
4459            'bind_interface': self.bind_interface,
4460            'database': self.database,
4461            'egress_filter': self.egress_filter,
4462            'healthy': self.healthy,
4463            'hostname': self.hostname,
4464            'id': self.id,
4465            'name': self.name,
4466            'password': self.password,
4467            'port': self.port,
4468            'port_override': self.port_override,
4469            'secret_store_id': self.secret_store_id,
4470            'tags': self.tags,
4471            'username': self.username,
4472        }
4473
4474    @classmethod
4475    def from_dict(cls, d):
4476        return cls(
4477            bind_interface=d.get('bind_interface'),
4478            database=d.get('database'),
4479            egress_filter=d.get('egress_filter'),
4480            healthy=d.get('healthy'),
4481            hostname=d.get('hostname'),
4482            id=d.get('id'),
4483            name=d.get('name'),
4484            password=d.get('password'),
4485            port=d.get('port'),
4486            port_override=d.get('port_override'),
4487            secret_store_id=d.get('secret_store_id'),
4488            tags=d.get('tags'),
4489            username=d.get('username'),
4490        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4389    def __init__(
4390        self,
4391        bind_interface=None,
4392        database=None,
4393        egress_filter=None,
4394        healthy=None,
4395        hostname=None,
4396        id=None,
4397        name=None,
4398        password=None,
4399        port=None,
4400        port_override=None,
4401        secret_store_id=None,
4402        tags=None,
4403        username=None,
4404    ):
4405        self.bind_interface = bind_interface if bind_interface is not None else ''
4406        '''
4407         Bind interface
4408        '''
4409        self.database = database if database is not None else ''
4410        self.egress_filter = egress_filter if egress_filter is not None else ''
4411        '''
4412         A filter applied to the routing logic to pin datasource to nodes.
4413        '''
4414        self.healthy = healthy if healthy is not None else False
4415        '''
4416         True if the datasource is reachable and the credentials are valid.
4417        '''
4418        self.hostname = hostname if hostname is not None else ''
4419        self.id = id if id is not None else ''
4420        '''
4421         Unique identifier of the Resource.
4422        '''
4423        self.name = name if name is not None else ''
4424        '''
4425         Unique human-readable name of the Resource.
4426        '''
4427        self.password = password if password is not None else ''
4428        self.port = port if port is not None else 0
4429        self.port_override = port_override if port_override is not None else 0
4430        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4431        '''
4432         ID of the secret store containing credentials for this resource, if any.
4433        '''
4434        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4435        '''
4436         Tags is a map of key, value pairs.
4437        '''
4438        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4457    def to_dict(self):
4458        return {
4459            'bind_interface': self.bind_interface,
4460            'database': self.database,
4461            'egress_filter': self.egress_filter,
4462            'healthy': self.healthy,
4463            'hostname': self.hostname,
4464            'id': self.id,
4465            'name': self.name,
4466            'password': self.password,
4467            'port': self.port,
4468            'port_override': self.port_override,
4469            'secret_store_id': self.secret_store_id,
4470            'tags': self.tags,
4471            'username': self.username,
4472        }
@classmethod
def from_dict(cls, d)
4474    @classmethod
4475    def from_dict(cls, d):
4476        return cls(
4477            bind_interface=d.get('bind_interface'),
4478            database=d.get('database'),
4479            egress_filter=d.get('egress_filter'),
4480            healthy=d.get('healthy'),
4481            hostname=d.get('hostname'),
4482            id=d.get('id'),
4483            name=d.get('name'),
4484            password=d.get('password'),
4485            port=d.get('port'),
4486            port_override=d.get('port_override'),
4487            secret_store_id=d.get('secret_store_id'),
4488            tags=d.get('tags'),
4489            username=d.get('username'),
4490        )
class DeleteResponseMetadata:
4493class DeleteResponseMetadata:
4494    '''
4495         DeleteResponseMetadata is reserved for future use.
4496    '''
4497    __slots__ = []
4498
4499    def __init__(self, ):
4500        pass
4501
4502    def __repr__(self):
4503        return '<sdm.DeleteResponseMetadata ' + \
4504            '>'
4505
4506    def to_dict(self):
4507        return {}
4508
4509    @classmethod
4510    def from_dict(cls, d):
4511        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4499    def __init__(self, ):
4500        pass
def to_dict(self)
4506    def to_dict(self):
4507        return {}
@classmethod
def from_dict(cls, d)
4509    @classmethod
4510    def from_dict(cls, d):
4511        return cls()
class DelineaStore:
4514class DelineaStore:
4515    '''
4516    DelineaStore is currently unstable, and its API may change, or it may be removed,
4517    without a major version bump.
4518    '''
4519    __slots__ = [
4520        'id',
4521        'name',
4522        'server_url',
4523        'tags',
4524        'tenant_name',
4525    ]
4526
4527    def __init__(
4528        self,
4529        id=None,
4530        name=None,
4531        server_url=None,
4532        tags=None,
4533        tenant_name=None,
4534    ):
4535        self.id = id if id is not None else ''
4536        '''
4537         Unique identifier of the SecretStore.
4538        '''
4539        self.name = name if name is not None else ''
4540        '''
4541         Unique human-readable name of the SecretStore.
4542        '''
4543        self.server_url = server_url if server_url is not None else ''
4544        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4545        '''
4546         Tags is a map of key, value pairs.
4547        '''
4548        self.tenant_name = tenant_name if tenant_name is not None else ''
4549
4550    def __repr__(self):
4551        return '<sdm.DelineaStore ' + \
4552            'id: ' + repr(self.id) + ' ' +\
4553            'name: ' + repr(self.name) + ' ' +\
4554            'server_url: ' + repr(self.server_url) + ' ' +\
4555            'tags: ' + repr(self.tags) + ' ' +\
4556            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
4557            '>'
4558
4559    def to_dict(self):
4560        return {
4561            'id': self.id,
4562            'name': self.name,
4563            'server_url': self.server_url,
4564            'tags': self.tags,
4565            'tenant_name': self.tenant_name,
4566        }
4567
4568    @classmethod
4569    def from_dict(cls, d):
4570        return cls(
4571            id=d.get('id'),
4572            name=d.get('name'),
4573            server_url=d.get('server_url'),
4574            tags=d.get('tags'),
4575            tenant_name=d.get('tenant_name'),
4576        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
4527    def __init__(
4528        self,
4529        id=None,
4530        name=None,
4531        server_url=None,
4532        tags=None,
4533        tenant_name=None,
4534    ):
4535        self.id = id if id is not None else ''
4536        '''
4537         Unique identifier of the SecretStore.
4538        '''
4539        self.name = name if name is not None else ''
4540        '''
4541         Unique human-readable name of the SecretStore.
4542        '''
4543        self.server_url = server_url if server_url is not None else ''
4544        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4545        '''
4546         Tags is a map of key, value pairs.
4547        '''
4548        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
4559    def to_dict(self):
4560        return {
4561            'id': self.id,
4562            'name': self.name,
4563            'server_url': self.server_url,
4564            'tags': self.tags,
4565            'tenant_name': self.tenant_name,
4566        }
@classmethod
def from_dict(cls, d)
4568    @classmethod
4569    def from_dict(cls, d):
4570        return cls(
4571            id=d.get('id'),
4572            name=d.get('name'),
4573            server_url=d.get('server_url'),
4574            tags=d.get('tags'),
4575            tenant_name=d.get('tenant_name'),
4576        )
class DocumentDBHost:
4579class DocumentDBHost:
4580    __slots__ = [
4581        'auth_database',
4582        'bind_interface',
4583        'egress_filter',
4584        'healthy',
4585        'hostname',
4586        'id',
4587        'name',
4588        'password',
4589        'port',
4590        'port_override',
4591        'secret_store_id',
4592        'tags',
4593        'username',
4594    ]
4595
4596    def __init__(
4597        self,
4598        auth_database=None,
4599        bind_interface=None,
4600        egress_filter=None,
4601        healthy=None,
4602        hostname=None,
4603        id=None,
4604        name=None,
4605        password=None,
4606        port=None,
4607        port_override=None,
4608        secret_store_id=None,
4609        tags=None,
4610        username=None,
4611    ):
4612        self.auth_database = auth_database if auth_database is not None else ''
4613        self.bind_interface = bind_interface if bind_interface is not None else ''
4614        '''
4615         Bind interface
4616        '''
4617        self.egress_filter = egress_filter if egress_filter is not None else ''
4618        '''
4619         A filter applied to the routing logic to pin datasource to nodes.
4620        '''
4621        self.healthy = healthy if healthy is not None else False
4622        '''
4623         True if the datasource is reachable and the credentials are valid.
4624        '''
4625        self.hostname = hostname if hostname is not None else ''
4626        self.id = id if id is not None else ''
4627        '''
4628         Unique identifier of the Resource.
4629        '''
4630        self.name = name if name is not None else ''
4631        '''
4632         Unique human-readable name of the Resource.
4633        '''
4634        self.password = password if password is not None else ''
4635        self.port = port if port is not None else 0
4636        self.port_override = port_override if port_override is not None else 0
4637        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4638        '''
4639         ID of the secret store containing credentials for this resource, if any.
4640        '''
4641        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4642        '''
4643         Tags is a map of key, value pairs.
4644        '''
4645        self.username = username if username is not None else ''
4646
4647    def __repr__(self):
4648        return '<sdm.DocumentDBHost ' + \
4649            'auth_database: ' + repr(self.auth_database) + ' ' +\
4650            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4651            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4652            'healthy: ' + repr(self.healthy) + ' ' +\
4653            'hostname: ' + repr(self.hostname) + ' ' +\
4654            'id: ' + repr(self.id) + ' ' +\
4655            'name: ' + repr(self.name) + ' ' +\
4656            'password: ' + repr(self.password) + ' ' +\
4657            'port: ' + repr(self.port) + ' ' +\
4658            'port_override: ' + repr(self.port_override) + ' ' +\
4659            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4660            'tags: ' + repr(self.tags) + ' ' +\
4661            'username: ' + repr(self.username) + ' ' +\
4662            '>'
4663
4664    def to_dict(self):
4665        return {
4666            'auth_database': self.auth_database,
4667            'bind_interface': self.bind_interface,
4668            'egress_filter': self.egress_filter,
4669            'healthy': self.healthy,
4670            'hostname': self.hostname,
4671            'id': self.id,
4672            'name': self.name,
4673            'password': self.password,
4674            'port': self.port,
4675            'port_override': self.port_override,
4676            'secret_store_id': self.secret_store_id,
4677            'tags': self.tags,
4678            'username': self.username,
4679        }
4680
4681    @classmethod
4682    def from_dict(cls, d):
4683        return cls(
4684            auth_database=d.get('auth_database'),
4685            bind_interface=d.get('bind_interface'),
4686            egress_filter=d.get('egress_filter'),
4687            healthy=d.get('healthy'),
4688            hostname=d.get('hostname'),
4689            id=d.get('id'),
4690            name=d.get('name'),
4691            password=d.get('password'),
4692            port=d.get('port'),
4693            port_override=d.get('port_override'),
4694            secret_store_id=d.get('secret_store_id'),
4695            tags=d.get('tags'),
4696            username=d.get('username'),
4697        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4596    def __init__(
4597        self,
4598        auth_database=None,
4599        bind_interface=None,
4600        egress_filter=None,
4601        healthy=None,
4602        hostname=None,
4603        id=None,
4604        name=None,
4605        password=None,
4606        port=None,
4607        port_override=None,
4608        secret_store_id=None,
4609        tags=None,
4610        username=None,
4611    ):
4612        self.auth_database = auth_database if auth_database is not None else ''
4613        self.bind_interface = bind_interface if bind_interface is not None else ''
4614        '''
4615         Bind interface
4616        '''
4617        self.egress_filter = egress_filter if egress_filter is not None else ''
4618        '''
4619         A filter applied to the routing logic to pin datasource to nodes.
4620        '''
4621        self.healthy = healthy if healthy is not None else False
4622        '''
4623         True if the datasource is reachable and the credentials are valid.
4624        '''
4625        self.hostname = hostname if hostname is not None else ''
4626        self.id = id if id is not None else ''
4627        '''
4628         Unique identifier of the Resource.
4629        '''
4630        self.name = name if name is not None else ''
4631        '''
4632         Unique human-readable name of the Resource.
4633        '''
4634        self.password = password if password is not None else ''
4635        self.port = port if port is not None else 0
4636        self.port_override = port_override if port_override is not None else 0
4637        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4638        '''
4639         ID of the secret store containing credentials for this resource, if any.
4640        '''
4641        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4642        '''
4643         Tags is a map of key, value pairs.
4644        '''
4645        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4664    def to_dict(self):
4665        return {
4666            'auth_database': self.auth_database,
4667            'bind_interface': self.bind_interface,
4668            'egress_filter': self.egress_filter,
4669            'healthy': self.healthy,
4670            'hostname': self.hostname,
4671            'id': self.id,
4672            'name': self.name,
4673            'password': self.password,
4674            'port': self.port,
4675            'port_override': self.port_override,
4676            'secret_store_id': self.secret_store_id,
4677            'tags': self.tags,
4678            'username': self.username,
4679        }
@classmethod
def from_dict(cls, d)
4681    @classmethod
4682    def from_dict(cls, d):
4683        return cls(
4684            auth_database=d.get('auth_database'),
4685            bind_interface=d.get('bind_interface'),
4686            egress_filter=d.get('egress_filter'),
4687            healthy=d.get('healthy'),
4688            hostname=d.get('hostname'),
4689            id=d.get('id'),
4690            name=d.get('name'),
4691            password=d.get('password'),
4692            port=d.get('port'),
4693            port_override=d.get('port_override'),
4694            secret_store_id=d.get('secret_store_id'),
4695            tags=d.get('tags'),
4696            username=d.get('username'),
4697        )
class DocumentDBReplicaSet:
4700class DocumentDBReplicaSet:
4701    __slots__ = [
4702        'auth_database',
4703        'bind_interface',
4704        'connect_to_replica',
4705        'egress_filter',
4706        'healthy',
4707        'hostname',
4708        'id',
4709        'name',
4710        'password',
4711        'port_override',
4712        'replica_set',
4713        'secret_store_id',
4714        'tags',
4715        'username',
4716    ]
4717
4718    def __init__(
4719        self,
4720        auth_database=None,
4721        bind_interface=None,
4722        connect_to_replica=None,
4723        egress_filter=None,
4724        healthy=None,
4725        hostname=None,
4726        id=None,
4727        name=None,
4728        password=None,
4729        port_override=None,
4730        replica_set=None,
4731        secret_store_id=None,
4732        tags=None,
4733        username=None,
4734    ):
4735        self.auth_database = auth_database if auth_database is not None else ''
4736        self.bind_interface = bind_interface if bind_interface is not None else ''
4737        '''
4738         Bind interface
4739        '''
4740        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4741        self.egress_filter = egress_filter if egress_filter is not None else ''
4742        '''
4743         A filter applied to the routing logic to pin datasource to nodes.
4744        '''
4745        self.healthy = healthy if healthy is not None else False
4746        '''
4747         True if the datasource is reachable and the credentials are valid.
4748        '''
4749        self.hostname = hostname if hostname is not None else ''
4750        '''
4751         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4752        '''
4753        self.id = id if id is not None else ''
4754        '''
4755         Unique identifier of the Resource.
4756        '''
4757        self.name = name if name is not None else ''
4758        '''
4759         Unique human-readable name of the Resource.
4760        '''
4761        self.password = password if password is not None else ''
4762        self.port_override = port_override if port_override is not None else 0
4763        self.replica_set = replica_set if replica_set is not None else ''
4764        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4765        '''
4766         ID of the secret store containing credentials for this resource, if any.
4767        '''
4768        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4769        '''
4770         Tags is a map of key, value pairs.
4771        '''
4772        self.username = username if username is not None else ''
4773
4774    def __repr__(self):
4775        return '<sdm.DocumentDBReplicaSet ' + \
4776            'auth_database: ' + repr(self.auth_database) + ' ' +\
4777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4778            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4780            'healthy: ' + repr(self.healthy) + ' ' +\
4781            'hostname: ' + repr(self.hostname) + ' ' +\
4782            'id: ' + repr(self.id) + ' ' +\
4783            'name: ' + repr(self.name) + ' ' +\
4784            'password: ' + repr(self.password) + ' ' +\
4785            'port_override: ' + repr(self.port_override) + ' ' +\
4786            'replica_set: ' + repr(self.replica_set) + ' ' +\
4787            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4788            'tags: ' + repr(self.tags) + ' ' +\
4789            'username: ' + repr(self.username) + ' ' +\
4790            '>'
4791
4792    def to_dict(self):
4793        return {
4794            'auth_database': self.auth_database,
4795            'bind_interface': self.bind_interface,
4796            'connect_to_replica': self.connect_to_replica,
4797            'egress_filter': self.egress_filter,
4798            'healthy': self.healthy,
4799            'hostname': self.hostname,
4800            'id': self.id,
4801            'name': self.name,
4802            'password': self.password,
4803            'port_override': self.port_override,
4804            'replica_set': self.replica_set,
4805            'secret_store_id': self.secret_store_id,
4806            'tags': self.tags,
4807            'username': self.username,
4808        }
4809
4810    @classmethod
4811    def from_dict(cls, d):
4812        return cls(
4813            auth_database=d.get('auth_database'),
4814            bind_interface=d.get('bind_interface'),
4815            connect_to_replica=d.get('connect_to_replica'),
4816            egress_filter=d.get('egress_filter'),
4817            healthy=d.get('healthy'),
4818            hostname=d.get('hostname'),
4819            id=d.get('id'),
4820            name=d.get('name'),
4821            password=d.get('password'),
4822            port_override=d.get('port_override'),
4823            replica_set=d.get('replica_set'),
4824            secret_store_id=d.get('secret_store_id'),
4825            tags=d.get('tags'),
4826            username=d.get('username'),
4827        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4718    def __init__(
4719        self,
4720        auth_database=None,
4721        bind_interface=None,
4722        connect_to_replica=None,
4723        egress_filter=None,
4724        healthy=None,
4725        hostname=None,
4726        id=None,
4727        name=None,
4728        password=None,
4729        port_override=None,
4730        replica_set=None,
4731        secret_store_id=None,
4732        tags=None,
4733        username=None,
4734    ):
4735        self.auth_database = auth_database if auth_database is not None else ''
4736        self.bind_interface = bind_interface if bind_interface is not None else ''
4737        '''
4738         Bind interface
4739        '''
4740        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4741        self.egress_filter = egress_filter if egress_filter is not None else ''
4742        '''
4743         A filter applied to the routing logic to pin datasource to nodes.
4744        '''
4745        self.healthy = healthy if healthy is not None else False
4746        '''
4747         True if the datasource is reachable and the credentials are valid.
4748        '''
4749        self.hostname = hostname if hostname is not None else ''
4750        '''
4751         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4752        '''
4753        self.id = id if id is not None else ''
4754        '''
4755         Unique identifier of the Resource.
4756        '''
4757        self.name = name if name is not None else ''
4758        '''
4759         Unique human-readable name of the Resource.
4760        '''
4761        self.password = password if password is not None else ''
4762        self.port_override = port_override if port_override is not None else 0
4763        self.replica_set = replica_set if replica_set is not None else ''
4764        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4765        '''
4766         ID of the secret store containing credentials for this resource, if any.
4767        '''
4768        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4769        '''
4770         Tags is a map of key, value pairs.
4771        '''
4772        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4792    def to_dict(self):
4793        return {
4794            'auth_database': self.auth_database,
4795            'bind_interface': self.bind_interface,
4796            'connect_to_replica': self.connect_to_replica,
4797            'egress_filter': self.egress_filter,
4798            'healthy': self.healthy,
4799            'hostname': self.hostname,
4800            'id': self.id,
4801            'name': self.name,
4802            'password': self.password,
4803            'port_override': self.port_override,
4804            'replica_set': self.replica_set,
4805            'secret_store_id': self.secret_store_id,
4806            'tags': self.tags,
4807            'username': self.username,
4808        }
@classmethod
def from_dict(cls, d)
4810    @classmethod
4811    def from_dict(cls, d):
4812        return cls(
4813            auth_database=d.get('auth_database'),
4814            bind_interface=d.get('bind_interface'),
4815            connect_to_replica=d.get('connect_to_replica'),
4816            egress_filter=d.get('egress_filter'),
4817            healthy=d.get('healthy'),
4818            hostname=d.get('hostname'),
4819            id=d.get('id'),
4820            name=d.get('name'),
4821            password=d.get('password'),
4822            port_override=d.get('port_override'),
4823            replica_set=d.get('replica_set'),
4824            secret_store_id=d.get('secret_store_id'),
4825            tags=d.get('tags'),
4826            username=d.get('username'),
4827        )
class Druid:
4830class Druid:
4831    __slots__ = [
4832        'bind_interface',
4833        'egress_filter',
4834        'healthy',
4835        'hostname',
4836        'id',
4837        'name',
4838        'password',
4839        'port',
4840        'port_override',
4841        'secret_store_id',
4842        'tags',
4843        'username',
4844    ]
4845
4846    def __init__(
4847        self,
4848        bind_interface=None,
4849        egress_filter=None,
4850        healthy=None,
4851        hostname=None,
4852        id=None,
4853        name=None,
4854        password=None,
4855        port=None,
4856        port_override=None,
4857        secret_store_id=None,
4858        tags=None,
4859        username=None,
4860    ):
4861        self.bind_interface = bind_interface if bind_interface is not None else ''
4862        '''
4863         Bind interface
4864        '''
4865        self.egress_filter = egress_filter if egress_filter is not None else ''
4866        '''
4867         A filter applied to the routing logic to pin datasource to nodes.
4868        '''
4869        self.healthy = healthy if healthy is not None else False
4870        '''
4871         True if the datasource is reachable and the credentials are valid.
4872        '''
4873        self.hostname = hostname if hostname is not None else ''
4874        self.id = id if id is not None else ''
4875        '''
4876         Unique identifier of the Resource.
4877        '''
4878        self.name = name if name is not None else ''
4879        '''
4880         Unique human-readable name of the Resource.
4881        '''
4882        self.password = password if password is not None else ''
4883        self.port = port if port is not None else 0
4884        self.port_override = port_override if port_override is not None else 0
4885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4886        '''
4887         ID of the secret store containing credentials for this resource, if any.
4888        '''
4889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4890        '''
4891         Tags is a map of key, value pairs.
4892        '''
4893        self.username = username if username is not None else ''
4894
4895    def __repr__(self):
4896        return '<sdm.Druid ' + \
4897            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4898            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4899            'healthy: ' + repr(self.healthy) + ' ' +\
4900            'hostname: ' + repr(self.hostname) + ' ' +\
4901            'id: ' + repr(self.id) + ' ' +\
4902            'name: ' + repr(self.name) + ' ' +\
4903            'password: ' + repr(self.password) + ' ' +\
4904            'port: ' + repr(self.port) + ' ' +\
4905            'port_override: ' + repr(self.port_override) + ' ' +\
4906            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4907            'tags: ' + repr(self.tags) + ' ' +\
4908            'username: ' + repr(self.username) + ' ' +\
4909            '>'
4910
4911    def to_dict(self):
4912        return {
4913            'bind_interface': self.bind_interface,
4914            'egress_filter': self.egress_filter,
4915            'healthy': self.healthy,
4916            'hostname': self.hostname,
4917            'id': self.id,
4918            'name': self.name,
4919            'password': self.password,
4920            'port': self.port,
4921            'port_override': self.port_override,
4922            'secret_store_id': self.secret_store_id,
4923            'tags': self.tags,
4924            'username': self.username,
4925        }
4926
4927    @classmethod
4928    def from_dict(cls, d):
4929        return cls(
4930            bind_interface=d.get('bind_interface'),
4931            egress_filter=d.get('egress_filter'),
4932            healthy=d.get('healthy'),
4933            hostname=d.get('hostname'),
4934            id=d.get('id'),
4935            name=d.get('name'),
4936            password=d.get('password'),
4937            port=d.get('port'),
4938            port_override=d.get('port_override'),
4939            secret_store_id=d.get('secret_store_id'),
4940            tags=d.get('tags'),
4941            username=d.get('username'),
4942        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4846    def __init__(
4847        self,
4848        bind_interface=None,
4849        egress_filter=None,
4850        healthy=None,
4851        hostname=None,
4852        id=None,
4853        name=None,
4854        password=None,
4855        port=None,
4856        port_override=None,
4857        secret_store_id=None,
4858        tags=None,
4859        username=None,
4860    ):
4861        self.bind_interface = bind_interface if bind_interface is not None else ''
4862        '''
4863         Bind interface
4864        '''
4865        self.egress_filter = egress_filter if egress_filter is not None else ''
4866        '''
4867         A filter applied to the routing logic to pin datasource to nodes.
4868        '''
4869        self.healthy = healthy if healthy is not None else False
4870        '''
4871         True if the datasource is reachable and the credentials are valid.
4872        '''
4873        self.hostname = hostname if hostname is not None else ''
4874        self.id = id if id is not None else ''
4875        '''
4876         Unique identifier of the Resource.
4877        '''
4878        self.name = name if name is not None else ''
4879        '''
4880         Unique human-readable name of the Resource.
4881        '''
4882        self.password = password if password is not None else ''
4883        self.port = port if port is not None else 0
4884        self.port_override = port_override if port_override is not None else 0
4885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4886        '''
4887         ID of the secret store containing credentials for this resource, if any.
4888        '''
4889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4890        '''
4891         Tags is a map of key, value pairs.
4892        '''
4893        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4911    def to_dict(self):
4912        return {
4913            'bind_interface': self.bind_interface,
4914            'egress_filter': self.egress_filter,
4915            'healthy': self.healthy,
4916            'hostname': self.hostname,
4917            'id': self.id,
4918            'name': self.name,
4919            'password': self.password,
4920            'port': self.port,
4921            'port_override': self.port_override,
4922            'secret_store_id': self.secret_store_id,
4923            'tags': self.tags,
4924            'username': self.username,
4925        }
@classmethod
def from_dict(cls, d)
4927    @classmethod
4928    def from_dict(cls, d):
4929        return cls(
4930            bind_interface=d.get('bind_interface'),
4931            egress_filter=d.get('egress_filter'),
4932            healthy=d.get('healthy'),
4933            hostname=d.get('hostname'),
4934            id=d.get('id'),
4935            name=d.get('name'),
4936            password=d.get('password'),
4937            port=d.get('port'),
4938            port_override=d.get('port_override'),
4939            secret_store_id=d.get('secret_store_id'),
4940            tags=d.get('tags'),
4941            username=d.get('username'),
4942        )
class DynamoDB:
4945class DynamoDB:
4946    __slots__ = [
4947        'access_key',
4948        'bind_interface',
4949        'egress_filter',
4950        'endpoint',
4951        'healthy',
4952        'id',
4953        'name',
4954        'port_override',
4955        'region',
4956        'role_arn',
4957        'role_external_id',
4958        'secret_access_key',
4959        'secret_store_id',
4960        'tags',
4961    ]
4962
4963    def __init__(
4964        self,
4965        access_key=None,
4966        bind_interface=None,
4967        egress_filter=None,
4968        endpoint=None,
4969        healthy=None,
4970        id=None,
4971        name=None,
4972        port_override=None,
4973        region=None,
4974        role_arn=None,
4975        role_external_id=None,
4976        secret_access_key=None,
4977        secret_store_id=None,
4978        tags=None,
4979    ):
4980        self.access_key = access_key if access_key is not None else ''
4981        self.bind_interface = bind_interface if bind_interface is not None else ''
4982        '''
4983         Bind interface
4984        '''
4985        self.egress_filter = egress_filter if egress_filter is not None else ''
4986        '''
4987         A filter applied to the routing logic to pin datasource to nodes.
4988        '''
4989        self.endpoint = endpoint if endpoint is not None else ''
4990        self.healthy = healthy if healthy is not None else False
4991        '''
4992         True if the datasource is reachable and the credentials are valid.
4993        '''
4994        self.id = id if id is not None else ''
4995        '''
4996         Unique identifier of the Resource.
4997        '''
4998        self.name = name if name is not None else ''
4999        '''
5000         Unique human-readable name of the Resource.
5001        '''
5002        self.port_override = port_override if port_override is not None else 0
5003        self.region = region if region is not None else ''
5004        self.role_arn = role_arn if role_arn is not None else ''
5005        self.role_external_id = role_external_id if role_external_id is not None else ''
5006        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
5007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5008        '''
5009         ID of the secret store containing credentials for this resource, if any.
5010        '''
5011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5012        '''
5013         Tags is a map of key, value pairs.
5014        '''
5015
5016    def __repr__(self):
5017        return '<sdm.DynamoDB ' + \
5018            'access_key: ' + repr(self.access_key) + ' ' +\
5019            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5020            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5021            'endpoint: ' + repr(self.endpoint) + ' ' +\
5022            'healthy: ' + repr(self.healthy) + ' ' +\
5023            'id: ' + repr(self.id) + ' ' +\
5024            'name: ' + repr(self.name) + ' ' +\
5025            'port_override: ' + repr(self.port_override) + ' ' +\
5026            'region: ' + repr(self.region) + ' ' +\
5027            'role_arn: ' + repr(self.role_arn) + ' ' +\
5028            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
5029            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
5030            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5031            'tags: ' + repr(self.tags) + ' ' +\
5032            '>'
5033
5034    def to_dict(self):
5035        return {
5036            'access_key': self.access_key,
5037            'bind_interface': self.bind_interface,
5038            'egress_filter': self.egress_filter,
5039            'endpoint': self.endpoint,
5040            'healthy': self.healthy,
5041            'id': self.id,
5042            'name': self.name,
5043            'port_override': self.port_override,
5044            'region': self.region,
5045            'role_arn': self.role_arn,
5046            'role_external_id': self.role_external_id,
5047            'secret_access_key': self.secret_access_key,
5048            'secret_store_id': self.secret_store_id,
5049            'tags': self.tags,
5050        }
5051
5052    @classmethod
5053    def from_dict(cls, d):
5054        return cls(
5055            access_key=d.get('access_key'),
5056            bind_interface=d.get('bind_interface'),
5057            egress_filter=d.get('egress_filter'),
5058            endpoint=d.get('endpoint'),
5059            healthy=d.get('healthy'),
5060            id=d.get('id'),
5061            name=d.get('name'),
5062            port_override=d.get('port_override'),
5063            region=d.get('region'),
5064            role_arn=d.get('role_arn'),
5065            role_external_id=d.get('role_external_id'),
5066            secret_access_key=d.get('secret_access_key'),
5067            secret_store_id=d.get('secret_store_id'),
5068            tags=d.get('tags'),
5069        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4963    def __init__(
4964        self,
4965        access_key=None,
4966        bind_interface=None,
4967        egress_filter=None,
4968        endpoint=None,
4969        healthy=None,
4970        id=None,
4971        name=None,
4972        port_override=None,
4973        region=None,
4974        role_arn=None,
4975        role_external_id=None,
4976        secret_access_key=None,
4977        secret_store_id=None,
4978        tags=None,
4979    ):
4980        self.access_key = access_key if access_key is not None else ''
4981        self.bind_interface = bind_interface if bind_interface is not None else ''
4982        '''
4983         Bind interface
4984        '''
4985        self.egress_filter = egress_filter if egress_filter is not None else ''
4986        '''
4987         A filter applied to the routing logic to pin datasource to nodes.
4988        '''
4989        self.endpoint = endpoint if endpoint is not None else ''
4990        self.healthy = healthy if healthy is not None else False
4991        '''
4992         True if the datasource is reachable and the credentials are valid.
4993        '''
4994        self.id = id if id is not None else ''
4995        '''
4996         Unique identifier of the Resource.
4997        '''
4998        self.name = name if name is not None else ''
4999        '''
5000         Unique human-readable name of the Resource.
5001        '''
5002        self.port_override = port_override if port_override is not None else 0
5003        self.region = region if region is not None else ''
5004        self.role_arn = role_arn if role_arn is not None else ''
5005        self.role_external_id = role_external_id if role_external_id is not None else ''
5006        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
5007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5008        '''
5009         ID of the secret store containing credentials for this resource, if any.
5010        '''
5011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5012        '''
5013         Tags is a map of key, value pairs.
5014        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5034    def to_dict(self):
5035        return {
5036            'access_key': self.access_key,
5037            'bind_interface': self.bind_interface,
5038            'egress_filter': self.egress_filter,
5039            'endpoint': self.endpoint,
5040            'healthy': self.healthy,
5041            'id': self.id,
5042            'name': self.name,
5043            'port_override': self.port_override,
5044            'region': self.region,
5045            'role_arn': self.role_arn,
5046            'role_external_id': self.role_external_id,
5047            'secret_access_key': self.secret_access_key,
5048            'secret_store_id': self.secret_store_id,
5049            'tags': self.tags,
5050        }
@classmethod
def from_dict(cls, d)
5052    @classmethod
5053    def from_dict(cls, d):
5054        return cls(
5055            access_key=d.get('access_key'),
5056            bind_interface=d.get('bind_interface'),
5057            egress_filter=d.get('egress_filter'),
5058            endpoint=d.get('endpoint'),
5059            healthy=d.get('healthy'),
5060            id=d.get('id'),
5061            name=d.get('name'),
5062            port_override=d.get('port_override'),
5063            region=d.get('region'),
5064            role_arn=d.get('role_arn'),
5065            role_external_id=d.get('role_external_id'),
5066            secret_access_key=d.get('secret_access_key'),
5067            secret_store_id=d.get('secret_store_id'),
5068            tags=d.get('tags'),
5069        )
class Elastic:
5072class Elastic:
5073    __slots__ = [
5074        'bind_interface',
5075        'egress_filter',
5076        'healthy',
5077        'hostname',
5078        'id',
5079        'name',
5080        'password',
5081        'port',
5082        'port_override',
5083        'secret_store_id',
5084        'tags',
5085        'tls_required',
5086        'username',
5087    ]
5088
5089    def __init__(
5090        self,
5091        bind_interface=None,
5092        egress_filter=None,
5093        healthy=None,
5094        hostname=None,
5095        id=None,
5096        name=None,
5097        password=None,
5098        port=None,
5099        port_override=None,
5100        secret_store_id=None,
5101        tags=None,
5102        tls_required=None,
5103        username=None,
5104    ):
5105        self.bind_interface = bind_interface if bind_interface is not None else ''
5106        '''
5107         Bind interface
5108        '''
5109        self.egress_filter = egress_filter if egress_filter is not None else ''
5110        '''
5111         A filter applied to the routing logic to pin datasource to nodes.
5112        '''
5113        self.healthy = healthy if healthy is not None else False
5114        '''
5115         True if the datasource is reachable and the credentials are valid.
5116        '''
5117        self.hostname = hostname if hostname is not None else ''
5118        self.id = id if id is not None else ''
5119        '''
5120         Unique identifier of the Resource.
5121        '''
5122        self.name = name if name is not None else ''
5123        '''
5124         Unique human-readable name of the Resource.
5125        '''
5126        self.password = password if password is not None else ''
5127        self.port = port if port is not None else 0
5128        self.port_override = port_override if port_override is not None else 0
5129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5130        '''
5131         ID of the secret store containing credentials for this resource, if any.
5132        '''
5133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5134        '''
5135         Tags is a map of key, value pairs.
5136        '''
5137        self.tls_required = tls_required if tls_required is not None else False
5138        self.username = username if username is not None else ''
5139
5140    def __repr__(self):
5141        return '<sdm.Elastic ' + \
5142            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5143            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5144            'healthy: ' + repr(self.healthy) + ' ' +\
5145            'hostname: ' + repr(self.hostname) + ' ' +\
5146            'id: ' + repr(self.id) + ' ' +\
5147            'name: ' + repr(self.name) + ' ' +\
5148            'password: ' + repr(self.password) + ' ' +\
5149            'port: ' + repr(self.port) + ' ' +\
5150            'port_override: ' + repr(self.port_override) + ' ' +\
5151            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5152            'tags: ' + repr(self.tags) + ' ' +\
5153            'tls_required: ' + repr(self.tls_required) + ' ' +\
5154            'username: ' + repr(self.username) + ' ' +\
5155            '>'
5156
5157    def to_dict(self):
5158        return {
5159            'bind_interface': self.bind_interface,
5160            'egress_filter': self.egress_filter,
5161            'healthy': self.healthy,
5162            'hostname': self.hostname,
5163            'id': self.id,
5164            'name': self.name,
5165            'password': self.password,
5166            'port': self.port,
5167            'port_override': self.port_override,
5168            'secret_store_id': self.secret_store_id,
5169            'tags': self.tags,
5170            'tls_required': self.tls_required,
5171            'username': self.username,
5172        }
5173
5174    @classmethod
5175    def from_dict(cls, d):
5176        return cls(
5177            bind_interface=d.get('bind_interface'),
5178            egress_filter=d.get('egress_filter'),
5179            healthy=d.get('healthy'),
5180            hostname=d.get('hostname'),
5181            id=d.get('id'),
5182            name=d.get('name'),
5183            password=d.get('password'),
5184            port=d.get('port'),
5185            port_override=d.get('port_override'),
5186            secret_store_id=d.get('secret_store_id'),
5187            tags=d.get('tags'),
5188            tls_required=d.get('tls_required'),
5189            username=d.get('username'),
5190        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
5089    def __init__(
5090        self,
5091        bind_interface=None,
5092        egress_filter=None,
5093        healthy=None,
5094        hostname=None,
5095        id=None,
5096        name=None,
5097        password=None,
5098        port=None,
5099        port_override=None,
5100        secret_store_id=None,
5101        tags=None,
5102        tls_required=None,
5103        username=None,
5104    ):
5105        self.bind_interface = bind_interface if bind_interface is not None else ''
5106        '''
5107         Bind interface
5108        '''
5109        self.egress_filter = egress_filter if egress_filter is not None else ''
5110        '''
5111         A filter applied to the routing logic to pin datasource to nodes.
5112        '''
5113        self.healthy = healthy if healthy is not None else False
5114        '''
5115         True if the datasource is reachable and the credentials are valid.
5116        '''
5117        self.hostname = hostname if hostname is not None else ''
5118        self.id = id if id is not None else ''
5119        '''
5120         Unique identifier of the Resource.
5121        '''
5122        self.name = name if name is not None else ''
5123        '''
5124         Unique human-readable name of the Resource.
5125        '''
5126        self.password = password if password is not None else ''
5127        self.port = port if port is not None else 0
5128        self.port_override = port_override if port_override is not None else 0
5129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5130        '''
5131         ID of the secret store containing credentials for this resource, if any.
5132        '''
5133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5134        '''
5135         Tags is a map of key, value pairs.
5136        '''
5137        self.tls_required = tls_required if tls_required is not None else False
5138        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
5157    def to_dict(self):
5158        return {
5159            'bind_interface': self.bind_interface,
5160            'egress_filter': self.egress_filter,
5161            'healthy': self.healthy,
5162            'hostname': self.hostname,
5163            'id': self.id,
5164            'name': self.name,
5165            'password': self.password,
5166            'port': self.port,
5167            'port_override': self.port_override,
5168            'secret_store_id': self.secret_store_id,
5169            'tags': self.tags,
5170            'tls_required': self.tls_required,
5171            'username': self.username,
5172        }
@classmethod
def from_dict(cls, d)
5174    @classmethod
5175    def from_dict(cls, d):
5176        return cls(
5177            bind_interface=d.get('bind_interface'),
5178            egress_filter=d.get('egress_filter'),
5179            healthy=d.get('healthy'),
5180            hostname=d.get('hostname'),
5181            id=d.get('id'),
5182            name=d.get('name'),
5183            password=d.get('password'),
5184            port=d.get('port'),
5185            port_override=d.get('port_override'),
5186            secret_store_id=d.get('secret_store_id'),
5187            tags=d.get('tags'),
5188            tls_required=d.get('tls_required'),
5189            username=d.get('username'),
5190        )
class ElasticacheRedis:
5193class ElasticacheRedis:
5194    __slots__ = [
5195        'bind_interface',
5196        'egress_filter',
5197        'healthy',
5198        'hostname',
5199        'id',
5200        'name',
5201        'password',
5202        'port',
5203        'port_override',
5204        'secret_store_id',
5205        'tags',
5206        'tls_required',
5207        'username',
5208    ]
5209
5210    def __init__(
5211        self,
5212        bind_interface=None,
5213        egress_filter=None,
5214        healthy=None,
5215        hostname=None,
5216        id=None,
5217        name=None,
5218        password=None,
5219        port=None,
5220        port_override=None,
5221        secret_store_id=None,
5222        tags=None,
5223        tls_required=None,
5224        username=None,
5225    ):
5226        self.bind_interface = bind_interface if bind_interface is not None else ''
5227        '''
5228         Bind interface
5229        '''
5230        self.egress_filter = egress_filter if egress_filter is not None else ''
5231        '''
5232         A filter applied to the routing logic to pin datasource to nodes.
5233        '''
5234        self.healthy = healthy if healthy is not None else False
5235        '''
5236         True if the datasource is reachable and the credentials are valid.
5237        '''
5238        self.hostname = hostname if hostname is not None else ''
5239        self.id = id if id is not None else ''
5240        '''
5241         Unique identifier of the Resource.
5242        '''
5243        self.name = name if name is not None else ''
5244        '''
5245         Unique human-readable name of the Resource.
5246        '''
5247        self.password = password if password is not None else ''
5248        self.port = port if port is not None else 0
5249        self.port_override = port_override if port_override is not None else 0
5250        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5251        '''
5252         ID of the secret store containing credentials for this resource, if any.
5253        '''
5254        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5255        '''
5256         Tags is a map of key, value pairs.
5257        '''
5258        self.tls_required = tls_required if tls_required is not None else False
5259        self.username = username if username is not None else ''
5260
5261    def __repr__(self):
5262        return '<sdm.ElasticacheRedis ' + \
5263            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5264            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5265            'healthy: ' + repr(self.healthy) + ' ' +\
5266            'hostname: ' + repr(self.hostname) + ' ' +\
5267            'id: ' + repr(self.id) + ' ' +\
5268            'name: ' + repr(self.name) + ' ' +\
5269            'password: ' + repr(self.password) + ' ' +\
5270            'port: ' + repr(self.port) + ' ' +\
5271            'port_override: ' + repr(self.port_override) + ' ' +\
5272            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5273            'tags: ' + repr(self.tags) + ' ' +\
5274            'tls_required: ' + repr(self.tls_required) + ' ' +\
5275            'username: ' + repr(self.username) + ' ' +\
5276            '>'
5277
5278    def to_dict(self):
5279        return {
5280            'bind_interface': self.bind_interface,
5281            'egress_filter': self.egress_filter,
5282            'healthy': self.healthy,
5283            'hostname': self.hostname,
5284            'id': self.id,
5285            'name': self.name,
5286            'password': self.password,
5287            'port': self.port,
5288            'port_override': self.port_override,
5289            'secret_store_id': self.secret_store_id,
5290            'tags': self.tags,
5291            'tls_required': self.tls_required,
5292            'username': self.username,
5293        }
5294
5295    @classmethod
5296    def from_dict(cls, d):
5297        return cls(
5298            bind_interface=d.get('bind_interface'),
5299            egress_filter=d.get('egress_filter'),
5300            healthy=d.get('healthy'),
5301            hostname=d.get('hostname'),
5302            id=d.get('id'),
5303            name=d.get('name'),
5304            password=d.get('password'),
5305            port=d.get('port'),
5306            port_override=d.get('port_override'),
5307            secret_store_id=d.get('secret_store_id'),
5308            tags=d.get('tags'),
5309            tls_required=d.get('tls_required'),
5310            username=d.get('username'),
5311        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
5210    def __init__(
5211        self,
5212        bind_interface=None,
5213        egress_filter=None,
5214        healthy=None,
5215        hostname=None,
5216        id=None,
5217        name=None,
5218        password=None,
5219        port=None,
5220        port_override=None,
5221        secret_store_id=None,
5222        tags=None,
5223        tls_required=None,
5224        username=None,
5225    ):
5226        self.bind_interface = bind_interface if bind_interface is not None else ''
5227        '''
5228         Bind interface
5229        '''
5230        self.egress_filter = egress_filter if egress_filter is not None else ''
5231        '''
5232         A filter applied to the routing logic to pin datasource to nodes.
5233        '''
5234        self.healthy = healthy if healthy is not None else False
5235        '''
5236         True if the datasource is reachable and the credentials are valid.
5237        '''
5238        self.hostname = hostname if hostname is not None else ''
5239        self.id = id if id is not None else ''
5240        '''
5241         Unique identifier of the Resource.
5242        '''
5243        self.name = name if name is not None else ''
5244        '''
5245         Unique human-readable name of the Resource.
5246        '''
5247        self.password = password if password is not None else ''
5248        self.port = port if port is not None else 0
5249        self.port_override = port_override if port_override is not None else 0
5250        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5251        '''
5252         ID of the secret store containing credentials for this resource, if any.
5253        '''
5254        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5255        '''
5256         Tags is a map of key, value pairs.
5257        '''
5258        self.tls_required = tls_required if tls_required is not None else False
5259        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
5278    def to_dict(self):
5279        return {
5280            'bind_interface': self.bind_interface,
5281            'egress_filter': self.egress_filter,
5282            'healthy': self.healthy,
5283            'hostname': self.hostname,
5284            'id': self.id,
5285            'name': self.name,
5286            'password': self.password,
5287            'port': self.port,
5288            'port_override': self.port_override,
5289            'secret_store_id': self.secret_store_id,
5290            'tags': self.tags,
5291            'tls_required': self.tls_required,
5292            'username': self.username,
5293        }
@classmethod
def from_dict(cls, d)
5295    @classmethod
5296    def from_dict(cls, d):
5297        return cls(
5298            bind_interface=d.get('bind_interface'),
5299            egress_filter=d.get('egress_filter'),
5300            healthy=d.get('healthy'),
5301            hostname=d.get('hostname'),
5302            id=d.get('id'),
5303            name=d.get('name'),
5304            password=d.get('password'),
5305            port=d.get('port'),
5306            port_override=d.get('port_override'),
5307            secret_store_id=d.get('secret_store_id'),
5308            tags=d.get('tags'),
5309            tls_required=d.get('tls_required'),
5310            username=d.get('username'),
5311        )
class GCP:
5314class GCP:
5315    __slots__ = [
5316        'bind_interface',
5317        'egress_filter',
5318        'healthy',
5319        'id',
5320        'keyfile',
5321        'name',
5322        'scopes',
5323        'secret_store_id',
5324        'tags',
5325    ]
5326
5327    def __init__(
5328        self,
5329        bind_interface=None,
5330        egress_filter=None,
5331        healthy=None,
5332        id=None,
5333        keyfile=None,
5334        name=None,
5335        scopes=None,
5336        secret_store_id=None,
5337        tags=None,
5338    ):
5339        self.bind_interface = bind_interface if bind_interface is not None else ''
5340        '''
5341         Bind interface
5342        '''
5343        self.egress_filter = egress_filter if egress_filter is not None else ''
5344        '''
5345         A filter applied to the routing logic to pin datasource to nodes.
5346        '''
5347        self.healthy = healthy if healthy is not None else False
5348        '''
5349         True if the datasource is reachable and the credentials are valid.
5350        '''
5351        self.id = id if id is not None else ''
5352        '''
5353         Unique identifier of the Resource.
5354        '''
5355        self.keyfile = keyfile if keyfile is not None else ''
5356        self.name = name if name is not None else ''
5357        '''
5358         Unique human-readable name of the Resource.
5359        '''
5360        self.scopes = scopes if scopes is not None else ''
5361        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5362        '''
5363         ID of the secret store containing credentials for this resource, if any.
5364        '''
5365        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5366        '''
5367         Tags is a map of key, value pairs.
5368        '''
5369
5370    def __repr__(self):
5371        return '<sdm.GCP ' + \
5372            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5373            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5374            'healthy: ' + repr(self.healthy) + ' ' +\
5375            'id: ' + repr(self.id) + ' ' +\
5376            'keyfile: ' + repr(self.keyfile) + ' ' +\
5377            'name: ' + repr(self.name) + ' ' +\
5378            'scopes: ' + repr(self.scopes) + ' ' +\
5379            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5380            'tags: ' + repr(self.tags) + ' ' +\
5381            '>'
5382
5383    def to_dict(self):
5384        return {
5385            'bind_interface': self.bind_interface,
5386            'egress_filter': self.egress_filter,
5387            'healthy': self.healthy,
5388            'id': self.id,
5389            'keyfile': self.keyfile,
5390            'name': self.name,
5391            'scopes': self.scopes,
5392            'secret_store_id': self.secret_store_id,
5393            'tags': self.tags,
5394        }
5395
5396    @classmethod
5397    def from_dict(cls, d):
5398        return cls(
5399            bind_interface=d.get('bind_interface'),
5400            egress_filter=d.get('egress_filter'),
5401            healthy=d.get('healthy'),
5402            id=d.get('id'),
5403            keyfile=d.get('keyfile'),
5404            name=d.get('name'),
5405            scopes=d.get('scopes'),
5406            secret_store_id=d.get('secret_store_id'),
5407            tags=d.get('tags'),
5408        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5327    def __init__(
5328        self,
5329        bind_interface=None,
5330        egress_filter=None,
5331        healthy=None,
5332        id=None,
5333        keyfile=None,
5334        name=None,
5335        scopes=None,
5336        secret_store_id=None,
5337        tags=None,
5338    ):
5339        self.bind_interface = bind_interface if bind_interface is not None else ''
5340        '''
5341         Bind interface
5342        '''
5343        self.egress_filter = egress_filter if egress_filter is not None else ''
5344        '''
5345         A filter applied to the routing logic to pin datasource to nodes.
5346        '''
5347        self.healthy = healthy if healthy is not None else False
5348        '''
5349         True if the datasource is reachable and the credentials are valid.
5350        '''
5351        self.id = id if id is not None else ''
5352        '''
5353         Unique identifier of the Resource.
5354        '''
5355        self.keyfile = keyfile if keyfile is not None else ''
5356        self.name = name if name is not None else ''
5357        '''
5358         Unique human-readable name of the Resource.
5359        '''
5360        self.scopes = scopes if scopes is not None else ''
5361        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5362        '''
5363         ID of the secret store containing credentials for this resource, if any.
5364        '''
5365        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5366        '''
5367         Tags is a map of key, value pairs.
5368        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5383    def to_dict(self):
5384        return {
5385            'bind_interface': self.bind_interface,
5386            'egress_filter': self.egress_filter,
5387            'healthy': self.healthy,
5388            'id': self.id,
5389            'keyfile': self.keyfile,
5390            'name': self.name,
5391            'scopes': self.scopes,
5392            'secret_store_id': self.secret_store_id,
5393            'tags': self.tags,
5394        }
@classmethod
def from_dict(cls, d)
5396    @classmethod
5397    def from_dict(cls, d):
5398        return cls(
5399            bind_interface=d.get('bind_interface'),
5400            egress_filter=d.get('egress_filter'),
5401            healthy=d.get('healthy'),
5402            id=d.get('id'),
5403            keyfile=d.get('keyfile'),
5404            name=d.get('name'),
5405            scopes=d.get('scopes'),
5406            secret_store_id=d.get('secret_store_id'),
5407            tags=d.get('tags'),
5408        )
class GCPStore:
5411class GCPStore:
5412    __slots__ = [
5413        'id',
5414        'name',
5415        'projectid',
5416        'tags',
5417    ]
5418
5419    def __init__(
5420        self,
5421        id=None,
5422        name=None,
5423        projectid=None,
5424        tags=None,
5425    ):
5426        self.id = id if id is not None else ''
5427        '''
5428         Unique identifier of the SecretStore.
5429        '''
5430        self.name = name if name is not None else ''
5431        '''
5432         Unique human-readable name of the SecretStore.
5433        '''
5434        self.projectid = projectid if projectid is not None else ''
5435        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5436        '''
5437         Tags is a map of key, value pairs.
5438        '''
5439
5440    def __repr__(self):
5441        return '<sdm.GCPStore ' + \
5442            'id: ' + repr(self.id) + ' ' +\
5443            'name: ' + repr(self.name) + ' ' +\
5444            'projectid: ' + repr(self.projectid) + ' ' +\
5445            'tags: ' + repr(self.tags) + ' ' +\
5446            '>'
5447
5448    def to_dict(self):
5449        return {
5450            'id': self.id,
5451            'name': self.name,
5452            'projectid': self.projectid,
5453            'tags': self.tags,
5454        }
5455
5456    @classmethod
5457    def from_dict(cls, d):
5458        return cls(
5459            id=d.get('id'),
5460            name=d.get('name'),
5461            projectid=d.get('projectid'),
5462            tags=d.get('tags'),
5463        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5419    def __init__(
5420        self,
5421        id=None,
5422        name=None,
5423        projectid=None,
5424        tags=None,
5425    ):
5426        self.id = id if id is not None else ''
5427        '''
5428         Unique identifier of the SecretStore.
5429        '''
5430        self.name = name if name is not None else ''
5431        '''
5432         Unique human-readable name of the SecretStore.
5433        '''
5434        self.projectid = projectid if projectid is not None else ''
5435        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5436        '''
5437         Tags is a map of key, value pairs.
5438        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5448    def to_dict(self):
5449        return {
5450            'id': self.id,
5451            'name': self.name,
5452            'projectid': self.projectid,
5453            'tags': self.tags,
5454        }
@classmethod
def from_dict(cls, d)
5456    @classmethod
5457    def from_dict(cls, d):
5458        return cls(
5459            id=d.get('id'),
5460            name=d.get('name'),
5461            projectid=d.get('projectid'),
5462            tags=d.get('tags'),
5463        )
class Gateway:
5466class Gateway:
5467    '''
5468         Gateway represents a StrongDM CLI installation running in gateway mode.
5469    '''
5470    __slots__ = [
5471        'bind_address',
5472        'device',
5473        'gateway_filter',
5474        'id',
5475        'listen_address',
5476        'location',
5477        'name',
5478        'state',
5479        'tags',
5480        'version',
5481    ]
5482
5483    def __init__(
5484        self,
5485        bind_address=None,
5486        device=None,
5487        gateway_filter=None,
5488        id=None,
5489        listen_address=None,
5490        location=None,
5491        name=None,
5492        state=None,
5493        tags=None,
5494        version=None,
5495    ):
5496        self.bind_address = bind_address if bind_address is not None else ''
5497        '''
5498         The hostname/port tuple which the gateway daemon will bind to.
5499         If not provided on create, set to "0.0.0.0:listen_address_port".
5500        '''
5501        self.device = device if device is not None else ''
5502        '''
5503         Device is a read only device name uploaded by the gateway process when 
5504         it comes online.
5505        '''
5506        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5507        '''
5508         GatewayFilter can be used to restrict the peering between relays and
5509         gateways.
5510        '''
5511        self.id = id if id is not None else ''
5512        '''
5513         Unique identifier of the Gateway.
5514        '''
5515        self.listen_address = listen_address if listen_address is not None else ''
5516        '''
5517         The public hostname/port tuple at which the gateway will be accessible to clients.
5518        '''
5519        self.location = location if location is not None else ''
5520        '''
5521         Location is a read only network location uploaded by the gateway process
5522         when it comes online.
5523        '''
5524        self.name = name if name is not None else ''
5525        '''
5526         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5527        '''
5528        self.state = state if state is not None else ''
5529        '''
5530         The current state of the gateway. One of: "new", "verifying_restart",
5531         "restarting", "started", "stopped", "dead", "unknown"
5532        '''
5533        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5534        '''
5535         Tags is a map of key, value pairs.
5536        '''
5537        self.version = version if version is not None else ''
5538        '''
5539         Version is a read only sdm binary version uploaded by the gateway process
5540         when it comes online.
5541        '''
5542
5543    def __repr__(self):
5544        return '<sdm.Gateway ' + \
5545            'bind_address: ' + repr(self.bind_address) + ' ' +\
5546            'device: ' + repr(self.device) + ' ' +\
5547            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5548            'id: ' + repr(self.id) + ' ' +\
5549            'listen_address: ' + repr(self.listen_address) + ' ' +\
5550            'location: ' + repr(self.location) + ' ' +\
5551            'name: ' + repr(self.name) + ' ' +\
5552            'state: ' + repr(self.state) + ' ' +\
5553            'tags: ' + repr(self.tags) + ' ' +\
5554            'version: ' + repr(self.version) + ' ' +\
5555            '>'
5556
5557    def to_dict(self):
5558        return {
5559            'bind_address': self.bind_address,
5560            'device': self.device,
5561            'gateway_filter': self.gateway_filter,
5562            'id': self.id,
5563            'listen_address': self.listen_address,
5564            'location': self.location,
5565            'name': self.name,
5566            'state': self.state,
5567            'tags': self.tags,
5568            'version': self.version,
5569        }
5570
5571    @classmethod
5572    def from_dict(cls, d):
5573        return cls(
5574            bind_address=d.get('bind_address'),
5575            device=d.get('device'),
5576            gateway_filter=d.get('gateway_filter'),
5577            id=d.get('id'),
5578            listen_address=d.get('listen_address'),
5579            location=d.get('location'),
5580            name=d.get('name'),
5581            state=d.get('state'),
5582            tags=d.get('tags'),
5583            version=d.get('version'),
5584        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, device=None, gateway_filter=None, id=None, listen_address=None, location=None, name=None, state=None, tags=None, version=None)
5483    def __init__(
5484        self,
5485        bind_address=None,
5486        device=None,
5487        gateway_filter=None,
5488        id=None,
5489        listen_address=None,
5490        location=None,
5491        name=None,
5492        state=None,
5493        tags=None,
5494        version=None,
5495    ):
5496        self.bind_address = bind_address if bind_address is not None else ''
5497        '''
5498         The hostname/port tuple which the gateway daemon will bind to.
5499         If not provided on create, set to "0.0.0.0:listen_address_port".
5500        '''
5501        self.device = device if device is not None else ''
5502        '''
5503         Device is a read only device name uploaded by the gateway process when 
5504         it comes online.
5505        '''
5506        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5507        '''
5508         GatewayFilter can be used to restrict the peering between relays and
5509         gateways.
5510        '''
5511        self.id = id if id is not None else ''
5512        '''
5513         Unique identifier of the Gateway.
5514        '''
5515        self.listen_address = listen_address if listen_address is not None else ''
5516        '''
5517         The public hostname/port tuple at which the gateway will be accessible to clients.
5518        '''
5519        self.location = location if location is not None else ''
5520        '''
5521         Location is a read only network location uploaded by the gateway process
5522         when it comes online.
5523        '''
5524        self.name = name if name is not None else ''
5525        '''
5526         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5527        '''
5528        self.state = state if state is not None else ''
5529        '''
5530         The current state of the gateway. One of: "new", "verifying_restart",
5531         "restarting", "started", "stopped", "dead", "unknown"
5532        '''
5533        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5534        '''
5535         Tags is a map of key, value pairs.
5536        '''
5537        self.version = version if version is not None else ''
5538        '''
5539         Version is a read only sdm binary version uploaded by the gateway process
5540         when it comes online.
5541        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
5557    def to_dict(self):
5558        return {
5559            'bind_address': self.bind_address,
5560            'device': self.device,
5561            'gateway_filter': self.gateway_filter,
5562            'id': self.id,
5563            'listen_address': self.listen_address,
5564            'location': self.location,
5565            'name': self.name,
5566            'state': self.state,
5567            'tags': self.tags,
5568            'version': self.version,
5569        }
@classmethod
def from_dict(cls, d)
5571    @classmethod
5572    def from_dict(cls, d):
5573        return cls(
5574            bind_address=d.get('bind_address'),
5575            device=d.get('device'),
5576            gateway_filter=d.get('gateway_filter'),
5577            id=d.get('id'),
5578            listen_address=d.get('listen_address'),
5579            location=d.get('location'),
5580            name=d.get('name'),
5581            state=d.get('state'),
5582            tags=d.get('tags'),
5583            version=d.get('version'),
5584        )
class GetResponseMetadata:
5587class GetResponseMetadata:
5588    '''
5589         GetResponseMetadata is reserved for future use.
5590    '''
5591    __slots__ = []
5592
5593    def __init__(self, ):
5594        pass
5595
5596    def __repr__(self):
5597        return '<sdm.GetResponseMetadata ' + \
5598            '>'
5599
5600    def to_dict(self):
5601        return {}
5602
5603    @classmethod
5604    def from_dict(cls, d):
5605        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5593    def __init__(self, ):
5594        pass
def to_dict(self)
5600    def to_dict(self):
5601        return {}
@classmethod
def from_dict(cls, d)
5603    @classmethod
5604    def from_dict(cls, d):
5605        return cls()
class GoogleGKE:
5608class GoogleGKE:
5609    __slots__ = [
5610        'bind_interface',
5611        'certificate_authority',
5612        'egress_filter',
5613        'endpoint',
5614        'healthcheck_namespace',
5615        'healthy',
5616        'id',
5617        'name',
5618        'remote_identity_group_id',
5619        'remote_identity_healthcheck_username',
5620        'secret_store_id',
5621        'service_account_key',
5622        'tags',
5623    ]
5624
5625    def __init__(
5626        self,
5627        bind_interface=None,
5628        certificate_authority=None,
5629        egress_filter=None,
5630        endpoint=None,
5631        healthcheck_namespace=None,
5632        healthy=None,
5633        id=None,
5634        name=None,
5635        remote_identity_group_id=None,
5636        remote_identity_healthcheck_username=None,
5637        secret_store_id=None,
5638        service_account_key=None,
5639        tags=None,
5640    ):
5641        self.bind_interface = bind_interface if bind_interface is not None else ''
5642        '''
5643         Bind interface
5644        '''
5645        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5646        self.egress_filter = egress_filter if egress_filter is not None else ''
5647        '''
5648         A filter applied to the routing logic to pin datasource to nodes.
5649        '''
5650        self.endpoint = endpoint if endpoint is not None else ''
5651        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5652        '''
5653         The path used to check the health of your connection.  Defaults to `default`.
5654        '''
5655        self.healthy = healthy if healthy is not None else False
5656        '''
5657         True if the datasource is reachable and the credentials are valid.
5658        '''
5659        self.id = id if id is not None else ''
5660        '''
5661         Unique identifier of the Resource.
5662        '''
5663        self.name = name if name is not None else ''
5664        '''
5665         Unique human-readable name of the Resource.
5666        '''
5667        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5668        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5669        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5670        '''
5671         ID of the secret store containing credentials for this resource, if any.
5672        '''
5673        self.service_account_key = service_account_key if service_account_key is not None else ''
5674        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5675        '''
5676         Tags is a map of key, value pairs.
5677        '''
5678
5679    def __repr__(self):
5680        return '<sdm.GoogleGKE ' + \
5681            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5682            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5683            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5684            'endpoint: ' + repr(self.endpoint) + ' ' +\
5685            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5686            'healthy: ' + repr(self.healthy) + ' ' +\
5687            'id: ' + repr(self.id) + ' ' +\
5688            'name: ' + repr(self.name) + ' ' +\
5689            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5690            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5691            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5692            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5693            'tags: ' + repr(self.tags) + ' ' +\
5694            '>'
5695
5696    def to_dict(self):
5697        return {
5698            'bind_interface': self.bind_interface,
5699            'certificate_authority': self.certificate_authority,
5700            'egress_filter': self.egress_filter,
5701            'endpoint': self.endpoint,
5702            'healthcheck_namespace': self.healthcheck_namespace,
5703            'healthy': self.healthy,
5704            'id': self.id,
5705            'name': self.name,
5706            'remote_identity_group_id': self.remote_identity_group_id,
5707            'remote_identity_healthcheck_username':
5708            self.remote_identity_healthcheck_username,
5709            'secret_store_id': self.secret_store_id,
5710            'service_account_key': self.service_account_key,
5711            'tags': self.tags,
5712        }
5713
5714    @classmethod
5715    def from_dict(cls, d):
5716        return cls(
5717            bind_interface=d.get('bind_interface'),
5718            certificate_authority=d.get('certificate_authority'),
5719            egress_filter=d.get('egress_filter'),
5720            endpoint=d.get('endpoint'),
5721            healthcheck_namespace=d.get('healthcheck_namespace'),
5722            healthy=d.get('healthy'),
5723            id=d.get('id'),
5724            name=d.get('name'),
5725            remote_identity_group_id=d.get('remote_identity_group_id'),
5726            remote_identity_healthcheck_username=d.get(
5727                'remote_identity_healthcheck_username'),
5728            secret_store_id=d.get('secret_store_id'),
5729            service_account_key=d.get('service_account_key'),
5730            tags=d.get('tags'),
5731        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5625    def __init__(
5626        self,
5627        bind_interface=None,
5628        certificate_authority=None,
5629        egress_filter=None,
5630        endpoint=None,
5631        healthcheck_namespace=None,
5632        healthy=None,
5633        id=None,
5634        name=None,
5635        remote_identity_group_id=None,
5636        remote_identity_healthcheck_username=None,
5637        secret_store_id=None,
5638        service_account_key=None,
5639        tags=None,
5640    ):
5641        self.bind_interface = bind_interface if bind_interface is not None else ''
5642        '''
5643         Bind interface
5644        '''
5645        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5646        self.egress_filter = egress_filter if egress_filter is not None else ''
5647        '''
5648         A filter applied to the routing logic to pin datasource to nodes.
5649        '''
5650        self.endpoint = endpoint if endpoint is not None else ''
5651        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5652        '''
5653         The path used to check the health of your connection.  Defaults to `default`.
5654        '''
5655        self.healthy = healthy if healthy is not None else False
5656        '''
5657         True if the datasource is reachable and the credentials are valid.
5658        '''
5659        self.id = id if id is not None else ''
5660        '''
5661         Unique identifier of the Resource.
5662        '''
5663        self.name = name if name is not None else ''
5664        '''
5665         Unique human-readable name of the Resource.
5666        '''
5667        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5668        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5669        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5670        '''
5671         ID of the secret store containing credentials for this resource, if any.
5672        '''
5673        self.service_account_key = service_account_key if service_account_key is not None else ''
5674        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5675        '''
5676         Tags is a map of key, value pairs.
5677        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5696    def to_dict(self):
5697        return {
5698            'bind_interface': self.bind_interface,
5699            'certificate_authority': self.certificate_authority,
5700            'egress_filter': self.egress_filter,
5701            'endpoint': self.endpoint,
5702            'healthcheck_namespace': self.healthcheck_namespace,
5703            'healthy': self.healthy,
5704            'id': self.id,
5705            'name': self.name,
5706            'remote_identity_group_id': self.remote_identity_group_id,
5707            'remote_identity_healthcheck_username':
5708            self.remote_identity_healthcheck_username,
5709            'secret_store_id': self.secret_store_id,
5710            'service_account_key': self.service_account_key,
5711            'tags': self.tags,
5712        }
@classmethod
def from_dict(cls, d)
5714    @classmethod
5715    def from_dict(cls, d):
5716        return cls(
5717            bind_interface=d.get('bind_interface'),
5718            certificate_authority=d.get('certificate_authority'),
5719            egress_filter=d.get('egress_filter'),
5720            endpoint=d.get('endpoint'),
5721            healthcheck_namespace=d.get('healthcheck_namespace'),
5722            healthy=d.get('healthy'),
5723            id=d.get('id'),
5724            name=d.get('name'),
5725            remote_identity_group_id=d.get('remote_identity_group_id'),
5726            remote_identity_healthcheck_username=d.get(
5727                'remote_identity_healthcheck_username'),
5728            secret_store_id=d.get('secret_store_id'),
5729            service_account_key=d.get('service_account_key'),
5730            tags=d.get('tags'),
5731        )
class GoogleGKEUserImpersonation:
5734class GoogleGKEUserImpersonation:
5735    __slots__ = [
5736        'bind_interface',
5737        'certificate_authority',
5738        'egress_filter',
5739        'endpoint',
5740        'healthcheck_namespace',
5741        'healthy',
5742        'id',
5743        'name',
5744        'secret_store_id',
5745        'service_account_key',
5746        'tags',
5747    ]
5748
5749    def __init__(
5750        self,
5751        bind_interface=None,
5752        certificate_authority=None,
5753        egress_filter=None,
5754        endpoint=None,
5755        healthcheck_namespace=None,
5756        healthy=None,
5757        id=None,
5758        name=None,
5759        secret_store_id=None,
5760        service_account_key=None,
5761        tags=None,
5762    ):
5763        self.bind_interface = bind_interface if bind_interface is not None else ''
5764        '''
5765         Bind interface
5766        '''
5767        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5768        self.egress_filter = egress_filter if egress_filter is not None else ''
5769        '''
5770         A filter applied to the routing logic to pin datasource to nodes.
5771        '''
5772        self.endpoint = endpoint if endpoint is not None else ''
5773        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5774        '''
5775         The path used to check the health of your connection.  Defaults to `default`.
5776        '''
5777        self.healthy = healthy if healthy is not None else False
5778        '''
5779         True if the datasource is reachable and the credentials are valid.
5780        '''
5781        self.id = id if id is not None else ''
5782        '''
5783         Unique identifier of the Resource.
5784        '''
5785        self.name = name if name is not None else ''
5786        '''
5787         Unique human-readable name of the Resource.
5788        '''
5789        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5790        '''
5791         ID of the secret store containing credentials for this resource, if any.
5792        '''
5793        self.service_account_key = service_account_key if service_account_key is not None else ''
5794        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5795        '''
5796         Tags is a map of key, value pairs.
5797        '''
5798
5799    def __repr__(self):
5800        return '<sdm.GoogleGKEUserImpersonation ' + \
5801            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5802            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5803            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5804            'endpoint: ' + repr(self.endpoint) + ' ' +\
5805            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5806            'healthy: ' + repr(self.healthy) + ' ' +\
5807            'id: ' + repr(self.id) + ' ' +\
5808            'name: ' + repr(self.name) + ' ' +\
5809            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5810            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5811            'tags: ' + repr(self.tags) + ' ' +\
5812            '>'
5813
5814    def to_dict(self):
5815        return {
5816            'bind_interface': self.bind_interface,
5817            'certificate_authority': self.certificate_authority,
5818            'egress_filter': self.egress_filter,
5819            'endpoint': self.endpoint,
5820            'healthcheck_namespace': self.healthcheck_namespace,
5821            'healthy': self.healthy,
5822            'id': self.id,
5823            'name': self.name,
5824            'secret_store_id': self.secret_store_id,
5825            'service_account_key': self.service_account_key,
5826            'tags': self.tags,
5827        }
5828
5829    @classmethod
5830    def from_dict(cls, d):
5831        return cls(
5832            bind_interface=d.get('bind_interface'),
5833            certificate_authority=d.get('certificate_authority'),
5834            egress_filter=d.get('egress_filter'),
5835            endpoint=d.get('endpoint'),
5836            healthcheck_namespace=d.get('healthcheck_namespace'),
5837            healthy=d.get('healthy'),
5838            id=d.get('id'),
5839            name=d.get('name'),
5840            secret_store_id=d.get('secret_store_id'),
5841            service_account_key=d.get('service_account_key'),
5842            tags=d.get('tags'),
5843        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5749    def __init__(
5750        self,
5751        bind_interface=None,
5752        certificate_authority=None,
5753        egress_filter=None,
5754        endpoint=None,
5755        healthcheck_namespace=None,
5756        healthy=None,
5757        id=None,
5758        name=None,
5759        secret_store_id=None,
5760        service_account_key=None,
5761        tags=None,
5762    ):
5763        self.bind_interface = bind_interface if bind_interface is not None else ''
5764        '''
5765         Bind interface
5766        '''
5767        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5768        self.egress_filter = egress_filter if egress_filter is not None else ''
5769        '''
5770         A filter applied to the routing logic to pin datasource to nodes.
5771        '''
5772        self.endpoint = endpoint if endpoint is not None else ''
5773        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5774        '''
5775         The path used to check the health of your connection.  Defaults to `default`.
5776        '''
5777        self.healthy = healthy if healthy is not None else False
5778        '''
5779         True if the datasource is reachable and the credentials are valid.
5780        '''
5781        self.id = id if id is not None else ''
5782        '''
5783         Unique identifier of the Resource.
5784        '''
5785        self.name = name if name is not None else ''
5786        '''
5787         Unique human-readable name of the Resource.
5788        '''
5789        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5790        '''
5791         ID of the secret store containing credentials for this resource, if any.
5792        '''
5793        self.service_account_key = service_account_key if service_account_key is not None else ''
5794        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5795        '''
5796         Tags is a map of key, value pairs.
5797        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5814    def to_dict(self):
5815        return {
5816            'bind_interface': self.bind_interface,
5817            'certificate_authority': self.certificate_authority,
5818            'egress_filter': self.egress_filter,
5819            'endpoint': self.endpoint,
5820            'healthcheck_namespace': self.healthcheck_namespace,
5821            'healthy': self.healthy,
5822            'id': self.id,
5823            'name': self.name,
5824            'secret_store_id': self.secret_store_id,
5825            'service_account_key': self.service_account_key,
5826            'tags': self.tags,
5827        }
@classmethod
def from_dict(cls, d)
5829    @classmethod
5830    def from_dict(cls, d):
5831        return cls(
5832            bind_interface=d.get('bind_interface'),
5833            certificate_authority=d.get('certificate_authority'),
5834            egress_filter=d.get('egress_filter'),
5835            endpoint=d.get('endpoint'),
5836            healthcheck_namespace=d.get('healthcheck_namespace'),
5837            healthy=d.get('healthy'),
5838            id=d.get('id'),
5839            name=d.get('name'),
5840            secret_store_id=d.get('secret_store_id'),
5841            service_account_key=d.get('service_account_key'),
5842            tags=d.get('tags'),
5843        )
class Greenplum:
5846class Greenplum:
5847    __slots__ = [
5848        'bind_interface',
5849        'database',
5850        'egress_filter',
5851        'healthy',
5852        'hostname',
5853        'id',
5854        'name',
5855        'override_database',
5856        'password',
5857        'port',
5858        'port_override',
5859        'secret_store_id',
5860        'tags',
5861        'username',
5862    ]
5863
5864    def __init__(
5865        self,
5866        bind_interface=None,
5867        database=None,
5868        egress_filter=None,
5869        healthy=None,
5870        hostname=None,
5871        id=None,
5872        name=None,
5873        override_database=None,
5874        password=None,
5875        port=None,
5876        port_override=None,
5877        secret_store_id=None,
5878        tags=None,
5879        username=None,
5880    ):
5881        self.bind_interface = bind_interface if bind_interface is not None else ''
5882        '''
5883         Bind interface
5884        '''
5885        self.database = database if database is not None else ''
5886        self.egress_filter = egress_filter if egress_filter is not None else ''
5887        '''
5888         A filter applied to the routing logic to pin datasource to nodes.
5889        '''
5890        self.healthy = healthy if healthy is not None else False
5891        '''
5892         True if the datasource is reachable and the credentials are valid.
5893        '''
5894        self.hostname = hostname if hostname is not None else ''
5895        self.id = id if id is not None else ''
5896        '''
5897         Unique identifier of the Resource.
5898        '''
5899        self.name = name if name is not None else ''
5900        '''
5901         Unique human-readable name of the Resource.
5902        '''
5903        self.override_database = override_database if override_database is not None else False
5904        self.password = password if password is not None else ''
5905        self.port = port if port is not None else 0
5906        self.port_override = port_override if port_override is not None else 0
5907        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5908        '''
5909         ID of the secret store containing credentials for this resource, if any.
5910        '''
5911        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5912        '''
5913         Tags is a map of key, value pairs.
5914        '''
5915        self.username = username if username is not None else ''
5916
5917    def __repr__(self):
5918        return '<sdm.Greenplum ' + \
5919            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5920            'database: ' + repr(self.database) + ' ' +\
5921            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5922            'healthy: ' + repr(self.healthy) + ' ' +\
5923            'hostname: ' + repr(self.hostname) + ' ' +\
5924            'id: ' + repr(self.id) + ' ' +\
5925            'name: ' + repr(self.name) + ' ' +\
5926            'override_database: ' + repr(self.override_database) + ' ' +\
5927            'password: ' + repr(self.password) + ' ' +\
5928            'port: ' + repr(self.port) + ' ' +\
5929            'port_override: ' + repr(self.port_override) + ' ' +\
5930            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5931            'tags: ' + repr(self.tags) + ' ' +\
5932            'username: ' + repr(self.username) + ' ' +\
5933            '>'
5934
5935    def to_dict(self):
5936        return {
5937            'bind_interface': self.bind_interface,
5938            'database': self.database,
5939            'egress_filter': self.egress_filter,
5940            'healthy': self.healthy,
5941            'hostname': self.hostname,
5942            'id': self.id,
5943            'name': self.name,
5944            'override_database': self.override_database,
5945            'password': self.password,
5946            'port': self.port,
5947            'port_override': self.port_override,
5948            'secret_store_id': self.secret_store_id,
5949            'tags': self.tags,
5950            'username': self.username,
5951        }
5952
5953    @classmethod
5954    def from_dict(cls, d):
5955        return cls(
5956            bind_interface=d.get('bind_interface'),
5957            database=d.get('database'),
5958            egress_filter=d.get('egress_filter'),
5959            healthy=d.get('healthy'),
5960            hostname=d.get('hostname'),
5961            id=d.get('id'),
5962            name=d.get('name'),
5963            override_database=d.get('override_database'),
5964            password=d.get('password'),
5965            port=d.get('port'),
5966            port_override=d.get('port_override'),
5967            secret_store_id=d.get('secret_store_id'),
5968            tags=d.get('tags'),
5969            username=d.get('username'),
5970        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5864    def __init__(
5865        self,
5866        bind_interface=None,
5867        database=None,
5868        egress_filter=None,
5869        healthy=None,
5870        hostname=None,
5871        id=None,
5872        name=None,
5873        override_database=None,
5874        password=None,
5875        port=None,
5876        port_override=None,
5877        secret_store_id=None,
5878        tags=None,
5879        username=None,
5880    ):
5881        self.bind_interface = bind_interface if bind_interface is not None else ''
5882        '''
5883         Bind interface
5884        '''
5885        self.database = database if database is not None else ''
5886        self.egress_filter = egress_filter if egress_filter is not None else ''
5887        '''
5888         A filter applied to the routing logic to pin datasource to nodes.
5889        '''
5890        self.healthy = healthy if healthy is not None else False
5891        '''
5892         True if the datasource is reachable and the credentials are valid.
5893        '''
5894        self.hostname = hostname if hostname is not None else ''
5895        self.id = id if id is not None else ''
5896        '''
5897         Unique identifier of the Resource.
5898        '''
5899        self.name = name if name is not None else ''
5900        '''
5901         Unique human-readable name of the Resource.
5902        '''
5903        self.override_database = override_database if override_database is not None else False
5904        self.password = password if password is not None else ''
5905        self.port = port if port is not None else 0
5906        self.port_override = port_override if port_override is not None else 0
5907        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5908        '''
5909         ID of the secret store containing credentials for this resource, if any.
5910        '''
5911        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5912        '''
5913         Tags is a map of key, value pairs.
5914        '''
5915        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5935    def to_dict(self):
5936        return {
5937            'bind_interface': self.bind_interface,
5938            'database': self.database,
5939            'egress_filter': self.egress_filter,
5940            'healthy': self.healthy,
5941            'hostname': self.hostname,
5942            'id': self.id,
5943            'name': self.name,
5944            'override_database': self.override_database,
5945            'password': self.password,
5946            'port': self.port,
5947            'port_override': self.port_override,
5948            'secret_store_id': self.secret_store_id,
5949            'tags': self.tags,
5950            'username': self.username,
5951        }
@classmethod
def from_dict(cls, d)
5953    @classmethod
5954    def from_dict(cls, d):
5955        return cls(
5956            bind_interface=d.get('bind_interface'),
5957            database=d.get('database'),
5958            egress_filter=d.get('egress_filter'),
5959            healthy=d.get('healthy'),
5960            hostname=d.get('hostname'),
5961            id=d.get('id'),
5962            name=d.get('name'),
5963            override_database=d.get('override_database'),
5964            password=d.get('password'),
5965            port=d.get('port'),
5966            port_override=d.get('port_override'),
5967            secret_store_id=d.get('secret_store_id'),
5968            tags=d.get('tags'),
5969            username=d.get('username'),
5970        )
class HTTPAuth:
5973class HTTPAuth:
5974    __slots__ = [
5975        'auth_header',
5976        'bind_interface',
5977        'default_path',
5978        'egress_filter',
5979        'headers_blacklist',
5980        'healthcheck_path',
5981        'healthy',
5982        'host_override',
5983        'id',
5984        'name',
5985        'secret_store_id',
5986        'subdomain',
5987        'tags',
5988        'url',
5989    ]
5990
5991    def __init__(
5992        self,
5993        auth_header=None,
5994        bind_interface=None,
5995        default_path=None,
5996        egress_filter=None,
5997        headers_blacklist=None,
5998        healthcheck_path=None,
5999        healthy=None,
6000        host_override=None,
6001        id=None,
6002        name=None,
6003        secret_store_id=None,
6004        subdomain=None,
6005        tags=None,
6006        url=None,
6007    ):
6008        self.auth_header = auth_header if auth_header is not None else ''
6009        self.bind_interface = bind_interface if bind_interface is not None else ''
6010        '''
6011         Bind interface
6012        '''
6013        self.default_path = default_path if default_path is not None else ''
6014        self.egress_filter = egress_filter if egress_filter is not None else ''
6015        '''
6016         A filter applied to the routing logic to pin datasource to nodes.
6017        '''
6018        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6019        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6020        self.healthy = healthy if healthy is not None else False
6021        '''
6022         True if the datasource is reachable and the credentials are valid.
6023        '''
6024        self.host_override = host_override if host_override is not None else ''
6025        self.id = id if id is not None else ''
6026        '''
6027         Unique identifier of the Resource.
6028        '''
6029        self.name = name if name is not None else ''
6030        '''
6031         Unique human-readable name of the Resource.
6032        '''
6033        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6034        '''
6035         ID of the secret store containing credentials for this resource, if any.
6036        '''
6037        self.subdomain = subdomain if subdomain is not None else ''
6038        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6039        '''
6040         Tags is a map of key, value pairs.
6041        '''
6042        self.url = url if url is not None else ''
6043
6044    def __repr__(self):
6045        return '<sdm.HTTPAuth ' + \
6046            'auth_header: ' + repr(self.auth_header) + ' ' +\
6047            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6048            'default_path: ' + repr(self.default_path) + ' ' +\
6049            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6050            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6051            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6052            'healthy: ' + repr(self.healthy) + ' ' +\
6053            'host_override: ' + repr(self.host_override) + ' ' +\
6054            'id: ' + repr(self.id) + ' ' +\
6055            'name: ' + repr(self.name) + ' ' +\
6056            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6057            'subdomain: ' + repr(self.subdomain) + ' ' +\
6058            'tags: ' + repr(self.tags) + ' ' +\
6059            'url: ' + repr(self.url) + ' ' +\
6060            '>'
6061
6062    def to_dict(self):
6063        return {
6064            'auth_header': self.auth_header,
6065            'bind_interface': self.bind_interface,
6066            'default_path': self.default_path,
6067            'egress_filter': self.egress_filter,
6068            'headers_blacklist': self.headers_blacklist,
6069            'healthcheck_path': self.healthcheck_path,
6070            'healthy': self.healthy,
6071            'host_override': self.host_override,
6072            'id': self.id,
6073            'name': self.name,
6074            'secret_store_id': self.secret_store_id,
6075            'subdomain': self.subdomain,
6076            'tags': self.tags,
6077            'url': self.url,
6078        }
6079
6080    @classmethod
6081    def from_dict(cls, d):
6082        return cls(
6083            auth_header=d.get('auth_header'),
6084            bind_interface=d.get('bind_interface'),
6085            default_path=d.get('default_path'),
6086            egress_filter=d.get('egress_filter'),
6087            headers_blacklist=d.get('headers_blacklist'),
6088            healthcheck_path=d.get('healthcheck_path'),
6089            healthy=d.get('healthy'),
6090            host_override=d.get('host_override'),
6091            id=d.get('id'),
6092            name=d.get('name'),
6093            secret_store_id=d.get('secret_store_id'),
6094            subdomain=d.get('subdomain'),
6095            tags=d.get('tags'),
6096            url=d.get('url'),
6097        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5991    def __init__(
5992        self,
5993        auth_header=None,
5994        bind_interface=None,
5995        default_path=None,
5996        egress_filter=None,
5997        headers_blacklist=None,
5998        healthcheck_path=None,
5999        healthy=None,
6000        host_override=None,
6001        id=None,
6002        name=None,
6003        secret_store_id=None,
6004        subdomain=None,
6005        tags=None,
6006        url=None,
6007    ):
6008        self.auth_header = auth_header if auth_header is not None else ''
6009        self.bind_interface = bind_interface if bind_interface is not None else ''
6010        '''
6011         Bind interface
6012        '''
6013        self.default_path = default_path if default_path is not None else ''
6014        self.egress_filter = egress_filter if egress_filter is not None else ''
6015        '''
6016         A filter applied to the routing logic to pin datasource to nodes.
6017        '''
6018        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6019        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6020        self.healthy = healthy if healthy is not None else False
6021        '''
6022         True if the datasource is reachable and the credentials are valid.
6023        '''
6024        self.host_override = host_override if host_override is not None else ''
6025        self.id = id if id is not None else ''
6026        '''
6027         Unique identifier of the Resource.
6028        '''
6029        self.name = name if name is not None else ''
6030        '''
6031         Unique human-readable name of the Resource.
6032        '''
6033        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6034        '''
6035         ID of the secret store containing credentials for this resource, if any.
6036        '''
6037        self.subdomain = subdomain if subdomain is not None else ''
6038        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6039        '''
6040         Tags is a map of key, value pairs.
6041        '''
6042        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6062    def to_dict(self):
6063        return {
6064            'auth_header': self.auth_header,
6065            'bind_interface': self.bind_interface,
6066            'default_path': self.default_path,
6067            'egress_filter': self.egress_filter,
6068            'headers_blacklist': self.headers_blacklist,
6069            'healthcheck_path': self.healthcheck_path,
6070            'healthy': self.healthy,
6071            'host_override': self.host_override,
6072            'id': self.id,
6073            'name': self.name,
6074            'secret_store_id': self.secret_store_id,
6075            'subdomain': self.subdomain,
6076            'tags': self.tags,
6077            'url': self.url,
6078        }
@classmethod
def from_dict(cls, d)
6080    @classmethod
6081    def from_dict(cls, d):
6082        return cls(
6083            auth_header=d.get('auth_header'),
6084            bind_interface=d.get('bind_interface'),
6085            default_path=d.get('default_path'),
6086            egress_filter=d.get('egress_filter'),
6087            headers_blacklist=d.get('headers_blacklist'),
6088            healthcheck_path=d.get('healthcheck_path'),
6089            healthy=d.get('healthy'),
6090            host_override=d.get('host_override'),
6091            id=d.get('id'),
6092            name=d.get('name'),
6093            secret_store_id=d.get('secret_store_id'),
6094            subdomain=d.get('subdomain'),
6095            tags=d.get('tags'),
6096            url=d.get('url'),
6097        )
class HTTPBasicAuth:
6100class HTTPBasicAuth:
6101    __slots__ = [
6102        'bind_interface',
6103        'default_path',
6104        'egress_filter',
6105        'headers_blacklist',
6106        'healthcheck_path',
6107        'healthy',
6108        'host_override',
6109        'id',
6110        'name',
6111        'password',
6112        'secret_store_id',
6113        'subdomain',
6114        'tags',
6115        'url',
6116        'username',
6117    ]
6118
6119    def __init__(
6120        self,
6121        bind_interface=None,
6122        default_path=None,
6123        egress_filter=None,
6124        headers_blacklist=None,
6125        healthcheck_path=None,
6126        healthy=None,
6127        host_override=None,
6128        id=None,
6129        name=None,
6130        password=None,
6131        secret_store_id=None,
6132        subdomain=None,
6133        tags=None,
6134        url=None,
6135        username=None,
6136    ):
6137        self.bind_interface = bind_interface if bind_interface is not None else ''
6138        '''
6139         Bind interface
6140        '''
6141        self.default_path = default_path if default_path is not None else ''
6142        self.egress_filter = egress_filter if egress_filter is not None else ''
6143        '''
6144         A filter applied to the routing logic to pin datasource to nodes.
6145        '''
6146        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6147        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6148        self.healthy = healthy if healthy is not None else False
6149        '''
6150         True if the datasource is reachable and the credentials are valid.
6151        '''
6152        self.host_override = host_override if host_override is not None else ''
6153        self.id = id if id is not None else ''
6154        '''
6155         Unique identifier of the Resource.
6156        '''
6157        self.name = name if name is not None else ''
6158        '''
6159         Unique human-readable name of the Resource.
6160        '''
6161        self.password = password if password is not None else ''
6162        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6163        '''
6164         ID of the secret store containing credentials for this resource, if any.
6165        '''
6166        self.subdomain = subdomain if subdomain is not None else ''
6167        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6168        '''
6169         Tags is a map of key, value pairs.
6170        '''
6171        self.url = url if url is not None else ''
6172        self.username = username if username is not None else ''
6173
6174    def __repr__(self):
6175        return '<sdm.HTTPBasicAuth ' + \
6176            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6177            'default_path: ' + repr(self.default_path) + ' ' +\
6178            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6179            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6180            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6181            'healthy: ' + repr(self.healthy) + ' ' +\
6182            'host_override: ' + repr(self.host_override) + ' ' +\
6183            'id: ' + repr(self.id) + ' ' +\
6184            'name: ' + repr(self.name) + ' ' +\
6185            'password: ' + repr(self.password) + ' ' +\
6186            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6187            'subdomain: ' + repr(self.subdomain) + ' ' +\
6188            'tags: ' + repr(self.tags) + ' ' +\
6189            'url: ' + repr(self.url) + ' ' +\
6190            'username: ' + repr(self.username) + ' ' +\
6191            '>'
6192
6193    def to_dict(self):
6194        return {
6195            'bind_interface': self.bind_interface,
6196            'default_path': self.default_path,
6197            'egress_filter': self.egress_filter,
6198            'headers_blacklist': self.headers_blacklist,
6199            'healthcheck_path': self.healthcheck_path,
6200            'healthy': self.healthy,
6201            'host_override': self.host_override,
6202            'id': self.id,
6203            'name': self.name,
6204            'password': self.password,
6205            'secret_store_id': self.secret_store_id,
6206            'subdomain': self.subdomain,
6207            'tags': self.tags,
6208            'url': self.url,
6209            'username': self.username,
6210        }
6211
6212    @classmethod
6213    def from_dict(cls, d):
6214        return cls(
6215            bind_interface=d.get('bind_interface'),
6216            default_path=d.get('default_path'),
6217            egress_filter=d.get('egress_filter'),
6218            headers_blacklist=d.get('headers_blacklist'),
6219            healthcheck_path=d.get('healthcheck_path'),
6220            healthy=d.get('healthy'),
6221            host_override=d.get('host_override'),
6222            id=d.get('id'),
6223            name=d.get('name'),
6224            password=d.get('password'),
6225            secret_store_id=d.get('secret_store_id'),
6226            subdomain=d.get('subdomain'),
6227            tags=d.get('tags'),
6228            url=d.get('url'),
6229            username=d.get('username'),
6230        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
6119    def __init__(
6120        self,
6121        bind_interface=None,
6122        default_path=None,
6123        egress_filter=None,
6124        headers_blacklist=None,
6125        healthcheck_path=None,
6126        healthy=None,
6127        host_override=None,
6128        id=None,
6129        name=None,
6130        password=None,
6131        secret_store_id=None,
6132        subdomain=None,
6133        tags=None,
6134        url=None,
6135        username=None,
6136    ):
6137        self.bind_interface = bind_interface if bind_interface is not None else ''
6138        '''
6139         Bind interface
6140        '''
6141        self.default_path = default_path if default_path is not None else ''
6142        self.egress_filter = egress_filter if egress_filter is not None else ''
6143        '''
6144         A filter applied to the routing logic to pin datasource to nodes.
6145        '''
6146        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6147        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6148        self.healthy = healthy if healthy is not None else False
6149        '''
6150         True if the datasource is reachable and the credentials are valid.
6151        '''
6152        self.host_override = host_override if host_override is not None else ''
6153        self.id = id if id is not None else ''
6154        '''
6155         Unique identifier of the Resource.
6156        '''
6157        self.name = name if name is not None else ''
6158        '''
6159         Unique human-readable name of the Resource.
6160        '''
6161        self.password = password if password is not None else ''
6162        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6163        '''
6164         ID of the secret store containing credentials for this resource, if any.
6165        '''
6166        self.subdomain = subdomain if subdomain is not None else ''
6167        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6168        '''
6169         Tags is a map of key, value pairs.
6170        '''
6171        self.url = url if url is not None else ''
6172        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
6193    def to_dict(self):
6194        return {
6195            'bind_interface': self.bind_interface,
6196            'default_path': self.default_path,
6197            'egress_filter': self.egress_filter,
6198            'headers_blacklist': self.headers_blacklist,
6199            'healthcheck_path': self.healthcheck_path,
6200            'healthy': self.healthy,
6201            'host_override': self.host_override,
6202            'id': self.id,
6203            'name': self.name,
6204            'password': self.password,
6205            'secret_store_id': self.secret_store_id,
6206            'subdomain': self.subdomain,
6207            'tags': self.tags,
6208            'url': self.url,
6209            'username': self.username,
6210        }
@classmethod
def from_dict(cls, d)
6212    @classmethod
6213    def from_dict(cls, d):
6214        return cls(
6215            bind_interface=d.get('bind_interface'),
6216            default_path=d.get('default_path'),
6217            egress_filter=d.get('egress_filter'),
6218            headers_blacklist=d.get('headers_blacklist'),
6219            healthcheck_path=d.get('healthcheck_path'),
6220            healthy=d.get('healthy'),
6221            host_override=d.get('host_override'),
6222            id=d.get('id'),
6223            name=d.get('name'),
6224            password=d.get('password'),
6225            secret_store_id=d.get('secret_store_id'),
6226            subdomain=d.get('subdomain'),
6227            tags=d.get('tags'),
6228            url=d.get('url'),
6229            username=d.get('username'),
6230        )
class HTTPNoAuth:
6233class HTTPNoAuth:
6234    __slots__ = [
6235        'bind_interface',
6236        'default_path',
6237        'egress_filter',
6238        'headers_blacklist',
6239        'healthcheck_path',
6240        'healthy',
6241        'host_override',
6242        'id',
6243        'name',
6244        'secret_store_id',
6245        'subdomain',
6246        'tags',
6247        'url',
6248    ]
6249
6250    def __init__(
6251        self,
6252        bind_interface=None,
6253        default_path=None,
6254        egress_filter=None,
6255        headers_blacklist=None,
6256        healthcheck_path=None,
6257        healthy=None,
6258        host_override=None,
6259        id=None,
6260        name=None,
6261        secret_store_id=None,
6262        subdomain=None,
6263        tags=None,
6264        url=None,
6265    ):
6266        self.bind_interface = bind_interface if bind_interface is not None else ''
6267        '''
6268         Bind interface
6269        '''
6270        self.default_path = default_path if default_path is not None else ''
6271        self.egress_filter = egress_filter if egress_filter is not None else ''
6272        '''
6273         A filter applied to the routing logic to pin datasource to nodes.
6274        '''
6275        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6276        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6277        self.healthy = healthy if healthy is not None else False
6278        '''
6279         True if the datasource is reachable and the credentials are valid.
6280        '''
6281        self.host_override = host_override if host_override is not None else ''
6282        self.id = id if id is not None else ''
6283        '''
6284         Unique identifier of the Resource.
6285        '''
6286        self.name = name if name is not None else ''
6287        '''
6288         Unique human-readable name of the Resource.
6289        '''
6290        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6291        '''
6292         ID of the secret store containing credentials for this resource, if any.
6293        '''
6294        self.subdomain = subdomain if subdomain is not None else ''
6295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6296        '''
6297         Tags is a map of key, value pairs.
6298        '''
6299        self.url = url if url is not None else ''
6300
6301    def __repr__(self):
6302        return '<sdm.HTTPNoAuth ' + \
6303            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6304            'default_path: ' + repr(self.default_path) + ' ' +\
6305            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6306            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6307            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6308            'healthy: ' + repr(self.healthy) + ' ' +\
6309            'host_override: ' + repr(self.host_override) + ' ' +\
6310            'id: ' + repr(self.id) + ' ' +\
6311            'name: ' + repr(self.name) + ' ' +\
6312            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6313            'subdomain: ' + repr(self.subdomain) + ' ' +\
6314            'tags: ' + repr(self.tags) + ' ' +\
6315            'url: ' + repr(self.url) + ' ' +\
6316            '>'
6317
6318    def to_dict(self):
6319        return {
6320            'bind_interface': self.bind_interface,
6321            'default_path': self.default_path,
6322            'egress_filter': self.egress_filter,
6323            'headers_blacklist': self.headers_blacklist,
6324            'healthcheck_path': self.healthcheck_path,
6325            'healthy': self.healthy,
6326            'host_override': self.host_override,
6327            'id': self.id,
6328            'name': self.name,
6329            'secret_store_id': self.secret_store_id,
6330            'subdomain': self.subdomain,
6331            'tags': self.tags,
6332            'url': self.url,
6333        }
6334
6335    @classmethod
6336    def from_dict(cls, d):
6337        return cls(
6338            bind_interface=d.get('bind_interface'),
6339            default_path=d.get('default_path'),
6340            egress_filter=d.get('egress_filter'),
6341            headers_blacklist=d.get('headers_blacklist'),
6342            healthcheck_path=d.get('healthcheck_path'),
6343            healthy=d.get('healthy'),
6344            host_override=d.get('host_override'),
6345            id=d.get('id'),
6346            name=d.get('name'),
6347            secret_store_id=d.get('secret_store_id'),
6348            subdomain=d.get('subdomain'),
6349            tags=d.get('tags'),
6350            url=d.get('url'),
6351        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6250    def __init__(
6251        self,
6252        bind_interface=None,
6253        default_path=None,
6254        egress_filter=None,
6255        headers_blacklist=None,
6256        healthcheck_path=None,
6257        healthy=None,
6258        host_override=None,
6259        id=None,
6260        name=None,
6261        secret_store_id=None,
6262        subdomain=None,
6263        tags=None,
6264        url=None,
6265    ):
6266        self.bind_interface = bind_interface if bind_interface is not None else ''
6267        '''
6268         Bind interface
6269        '''
6270        self.default_path = default_path if default_path is not None else ''
6271        self.egress_filter = egress_filter if egress_filter is not None else ''
6272        '''
6273         A filter applied to the routing logic to pin datasource to nodes.
6274        '''
6275        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6276        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6277        self.healthy = healthy if healthy is not None else False
6278        '''
6279         True if the datasource is reachable and the credentials are valid.
6280        '''
6281        self.host_override = host_override if host_override is not None else ''
6282        self.id = id if id is not None else ''
6283        '''
6284         Unique identifier of the Resource.
6285        '''
6286        self.name = name if name is not None else ''
6287        '''
6288         Unique human-readable name of the Resource.
6289        '''
6290        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6291        '''
6292         ID of the secret store containing credentials for this resource, if any.
6293        '''
6294        self.subdomain = subdomain if subdomain is not None else ''
6295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6296        '''
6297         Tags is a map of key, value pairs.
6298        '''
6299        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6318    def to_dict(self):
6319        return {
6320            'bind_interface': self.bind_interface,
6321            'default_path': self.default_path,
6322            'egress_filter': self.egress_filter,
6323            'headers_blacklist': self.headers_blacklist,
6324            'healthcheck_path': self.healthcheck_path,
6325            'healthy': self.healthy,
6326            'host_override': self.host_override,
6327            'id': self.id,
6328            'name': self.name,
6329            'secret_store_id': self.secret_store_id,
6330            'subdomain': self.subdomain,
6331            'tags': self.tags,
6332            'url': self.url,
6333        }
@classmethod
def from_dict(cls, d)
6335    @classmethod
6336    def from_dict(cls, d):
6337        return cls(
6338            bind_interface=d.get('bind_interface'),
6339            default_path=d.get('default_path'),
6340            egress_filter=d.get('egress_filter'),
6341            headers_blacklist=d.get('headers_blacklist'),
6342            healthcheck_path=d.get('healthcheck_path'),
6343            healthy=d.get('healthy'),
6344            host_override=d.get('host_override'),
6345            id=d.get('id'),
6346            name=d.get('name'),
6347            secret_store_id=d.get('secret_store_id'),
6348            subdomain=d.get('subdomain'),
6349            tags=d.get('tags'),
6350            url=d.get('url'),
6351        )
class Kubernetes:
6354class Kubernetes:
6355    __slots__ = [
6356        'bind_interface',
6357        'certificate_authority',
6358        'client_certificate',
6359        'client_key',
6360        'egress_filter',
6361        'healthcheck_namespace',
6362        'healthy',
6363        'hostname',
6364        'id',
6365        'name',
6366        'port',
6367        'port_override',
6368        'remote_identity_group_id',
6369        'remote_identity_healthcheck_username',
6370        'secret_store_id',
6371        'tags',
6372    ]
6373
6374    def __init__(
6375        self,
6376        bind_interface=None,
6377        certificate_authority=None,
6378        client_certificate=None,
6379        client_key=None,
6380        egress_filter=None,
6381        healthcheck_namespace=None,
6382        healthy=None,
6383        hostname=None,
6384        id=None,
6385        name=None,
6386        port=None,
6387        port_override=None,
6388        remote_identity_group_id=None,
6389        remote_identity_healthcheck_username=None,
6390        secret_store_id=None,
6391        tags=None,
6392    ):
6393        self.bind_interface = bind_interface if bind_interface is not None else ''
6394        '''
6395         Bind interface
6396        '''
6397        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6398        self.client_certificate = client_certificate if client_certificate is not None else ''
6399        self.client_key = client_key if client_key is not None else ''
6400        self.egress_filter = egress_filter if egress_filter is not None else ''
6401        '''
6402         A filter applied to the routing logic to pin datasource to nodes.
6403        '''
6404        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6405        '''
6406         The path used to check the health of your connection.  Defaults to `default`.
6407        '''
6408        self.healthy = healthy if healthy is not None else False
6409        '''
6410         True if the datasource is reachable and the credentials are valid.
6411        '''
6412        self.hostname = hostname if hostname is not None else ''
6413        self.id = id if id is not None else ''
6414        '''
6415         Unique identifier of the Resource.
6416        '''
6417        self.name = name if name is not None else ''
6418        '''
6419         Unique human-readable name of the Resource.
6420        '''
6421        self.port = port if port is not None else 0
6422        self.port_override = port_override if port_override is not None else 0
6423        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6424        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6425        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6426        '''
6427         ID of the secret store containing credentials for this resource, if any.
6428        '''
6429        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6430        '''
6431         Tags is a map of key, value pairs.
6432        '''
6433
6434    def __repr__(self):
6435        return '<sdm.Kubernetes ' + \
6436            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6437            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6438            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6439            'client_key: ' + repr(self.client_key) + ' ' +\
6440            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6441            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6442            'healthy: ' + repr(self.healthy) + ' ' +\
6443            'hostname: ' + repr(self.hostname) + ' ' +\
6444            'id: ' + repr(self.id) + ' ' +\
6445            'name: ' + repr(self.name) + ' ' +\
6446            'port: ' + repr(self.port) + ' ' +\
6447            'port_override: ' + repr(self.port_override) + ' ' +\
6448            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6449            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6450            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6451            'tags: ' + repr(self.tags) + ' ' +\
6452            '>'
6453
6454    def to_dict(self):
6455        return {
6456            'bind_interface': self.bind_interface,
6457            'certificate_authority': self.certificate_authority,
6458            'client_certificate': self.client_certificate,
6459            'client_key': self.client_key,
6460            'egress_filter': self.egress_filter,
6461            'healthcheck_namespace': self.healthcheck_namespace,
6462            'healthy': self.healthy,
6463            'hostname': self.hostname,
6464            'id': self.id,
6465            'name': self.name,
6466            'port': self.port,
6467            'port_override': self.port_override,
6468            'remote_identity_group_id': self.remote_identity_group_id,
6469            'remote_identity_healthcheck_username':
6470            self.remote_identity_healthcheck_username,
6471            'secret_store_id': self.secret_store_id,
6472            'tags': self.tags,
6473        }
6474
6475    @classmethod
6476    def from_dict(cls, d):
6477        return cls(
6478            bind_interface=d.get('bind_interface'),
6479            certificate_authority=d.get('certificate_authority'),
6480            client_certificate=d.get('client_certificate'),
6481            client_key=d.get('client_key'),
6482            egress_filter=d.get('egress_filter'),
6483            healthcheck_namespace=d.get('healthcheck_namespace'),
6484            healthy=d.get('healthy'),
6485            hostname=d.get('hostname'),
6486            id=d.get('id'),
6487            name=d.get('name'),
6488            port=d.get('port'),
6489            port_override=d.get('port_override'),
6490            remote_identity_group_id=d.get('remote_identity_group_id'),
6491            remote_identity_healthcheck_username=d.get(
6492                'remote_identity_healthcheck_username'),
6493            secret_store_id=d.get('secret_store_id'),
6494            tags=d.get('tags'),
6495        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6374    def __init__(
6375        self,
6376        bind_interface=None,
6377        certificate_authority=None,
6378        client_certificate=None,
6379        client_key=None,
6380        egress_filter=None,
6381        healthcheck_namespace=None,
6382        healthy=None,
6383        hostname=None,
6384        id=None,
6385        name=None,
6386        port=None,
6387        port_override=None,
6388        remote_identity_group_id=None,
6389        remote_identity_healthcheck_username=None,
6390        secret_store_id=None,
6391        tags=None,
6392    ):
6393        self.bind_interface = bind_interface if bind_interface is not None else ''
6394        '''
6395         Bind interface
6396        '''
6397        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6398        self.client_certificate = client_certificate if client_certificate is not None else ''
6399        self.client_key = client_key if client_key is not None else ''
6400        self.egress_filter = egress_filter if egress_filter is not None else ''
6401        '''
6402         A filter applied to the routing logic to pin datasource to nodes.
6403        '''
6404        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6405        '''
6406         The path used to check the health of your connection.  Defaults to `default`.
6407        '''
6408        self.healthy = healthy if healthy is not None else False
6409        '''
6410         True if the datasource is reachable and the credentials are valid.
6411        '''
6412        self.hostname = hostname if hostname is not None else ''
6413        self.id = id if id is not None else ''
6414        '''
6415         Unique identifier of the Resource.
6416        '''
6417        self.name = name if name is not None else ''
6418        '''
6419         Unique human-readable name of the Resource.
6420        '''
6421        self.port = port if port is not None else 0
6422        self.port_override = port_override if port_override is not None else 0
6423        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6424        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6425        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6426        '''
6427         ID of the secret store containing credentials for this resource, if any.
6428        '''
6429        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6430        '''
6431         Tags is a map of key, value pairs.
6432        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6454    def to_dict(self):
6455        return {
6456            'bind_interface': self.bind_interface,
6457            'certificate_authority': self.certificate_authority,
6458            'client_certificate': self.client_certificate,
6459            'client_key': self.client_key,
6460            'egress_filter': self.egress_filter,
6461            'healthcheck_namespace': self.healthcheck_namespace,
6462            'healthy': self.healthy,
6463            'hostname': self.hostname,
6464            'id': self.id,
6465            'name': self.name,
6466            'port': self.port,
6467            'port_override': self.port_override,
6468            'remote_identity_group_id': self.remote_identity_group_id,
6469            'remote_identity_healthcheck_username':
6470            self.remote_identity_healthcheck_username,
6471            'secret_store_id': self.secret_store_id,
6472            'tags': self.tags,
6473        }
@classmethod
def from_dict(cls, d)
6475    @classmethod
6476    def from_dict(cls, d):
6477        return cls(
6478            bind_interface=d.get('bind_interface'),
6479            certificate_authority=d.get('certificate_authority'),
6480            client_certificate=d.get('client_certificate'),
6481            client_key=d.get('client_key'),
6482            egress_filter=d.get('egress_filter'),
6483            healthcheck_namespace=d.get('healthcheck_namespace'),
6484            healthy=d.get('healthy'),
6485            hostname=d.get('hostname'),
6486            id=d.get('id'),
6487            name=d.get('name'),
6488            port=d.get('port'),
6489            port_override=d.get('port_override'),
6490            remote_identity_group_id=d.get('remote_identity_group_id'),
6491            remote_identity_healthcheck_username=d.get(
6492                'remote_identity_healthcheck_username'),
6493            secret_store_id=d.get('secret_store_id'),
6494            tags=d.get('tags'),
6495        )
class KubernetesBasicAuth:
6498class KubernetesBasicAuth:
6499    __slots__ = [
6500        'bind_interface',
6501        'egress_filter',
6502        'healthcheck_namespace',
6503        'healthy',
6504        'hostname',
6505        'id',
6506        'name',
6507        'password',
6508        'port',
6509        'port_override',
6510        'secret_store_id',
6511        'tags',
6512        'username',
6513    ]
6514
6515    def __init__(
6516        self,
6517        bind_interface=None,
6518        egress_filter=None,
6519        healthcheck_namespace=None,
6520        healthy=None,
6521        hostname=None,
6522        id=None,
6523        name=None,
6524        password=None,
6525        port=None,
6526        port_override=None,
6527        secret_store_id=None,
6528        tags=None,
6529        username=None,
6530    ):
6531        self.bind_interface = bind_interface if bind_interface is not None else ''
6532        '''
6533         Bind interface
6534        '''
6535        self.egress_filter = egress_filter if egress_filter is not None else ''
6536        '''
6537         A filter applied to the routing logic to pin datasource to nodes.
6538        '''
6539        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6540        '''
6541         The path used to check the health of your connection.  Defaults to `default`.
6542        '''
6543        self.healthy = healthy if healthy is not None else False
6544        '''
6545         True if the datasource is reachable and the credentials are valid.
6546        '''
6547        self.hostname = hostname if hostname is not None else ''
6548        self.id = id if id is not None else ''
6549        '''
6550         Unique identifier of the Resource.
6551        '''
6552        self.name = name if name is not None else ''
6553        '''
6554         Unique human-readable name of the Resource.
6555        '''
6556        self.password = password if password is not None else ''
6557        self.port = port if port is not None else 0
6558        self.port_override = port_override if port_override is not None else 0
6559        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6560        '''
6561         ID of the secret store containing credentials for this resource, if any.
6562        '''
6563        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6564        '''
6565         Tags is a map of key, value pairs.
6566        '''
6567        self.username = username if username is not None else ''
6568
6569    def __repr__(self):
6570        return '<sdm.KubernetesBasicAuth ' + \
6571            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6572            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6573            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6574            'healthy: ' + repr(self.healthy) + ' ' +\
6575            'hostname: ' + repr(self.hostname) + ' ' +\
6576            'id: ' + repr(self.id) + ' ' +\
6577            'name: ' + repr(self.name) + ' ' +\
6578            'password: ' + repr(self.password) + ' ' +\
6579            'port: ' + repr(self.port) + ' ' +\
6580            'port_override: ' + repr(self.port_override) + ' ' +\
6581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6582            'tags: ' + repr(self.tags) + ' ' +\
6583            'username: ' + repr(self.username) + ' ' +\
6584            '>'
6585
6586    def to_dict(self):
6587        return {
6588            'bind_interface': self.bind_interface,
6589            'egress_filter': self.egress_filter,
6590            'healthcheck_namespace': self.healthcheck_namespace,
6591            'healthy': self.healthy,
6592            'hostname': self.hostname,
6593            'id': self.id,
6594            'name': self.name,
6595            'password': self.password,
6596            'port': self.port,
6597            'port_override': self.port_override,
6598            'secret_store_id': self.secret_store_id,
6599            'tags': self.tags,
6600            'username': self.username,
6601        }
6602
6603    @classmethod
6604    def from_dict(cls, d):
6605        return cls(
6606            bind_interface=d.get('bind_interface'),
6607            egress_filter=d.get('egress_filter'),
6608            healthcheck_namespace=d.get('healthcheck_namespace'),
6609            healthy=d.get('healthy'),
6610            hostname=d.get('hostname'),
6611            id=d.get('id'),
6612            name=d.get('name'),
6613            password=d.get('password'),
6614            port=d.get('port'),
6615            port_override=d.get('port_override'),
6616            secret_store_id=d.get('secret_store_id'),
6617            tags=d.get('tags'),
6618            username=d.get('username'),
6619        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6515    def __init__(
6516        self,
6517        bind_interface=None,
6518        egress_filter=None,
6519        healthcheck_namespace=None,
6520        healthy=None,
6521        hostname=None,
6522        id=None,
6523        name=None,
6524        password=None,
6525        port=None,
6526        port_override=None,
6527        secret_store_id=None,
6528        tags=None,
6529        username=None,
6530    ):
6531        self.bind_interface = bind_interface if bind_interface is not None else ''
6532        '''
6533         Bind interface
6534        '''
6535        self.egress_filter = egress_filter if egress_filter is not None else ''
6536        '''
6537         A filter applied to the routing logic to pin datasource to nodes.
6538        '''
6539        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6540        '''
6541         The path used to check the health of your connection.  Defaults to `default`.
6542        '''
6543        self.healthy = healthy if healthy is not None else False
6544        '''
6545         True if the datasource is reachable and the credentials are valid.
6546        '''
6547        self.hostname = hostname if hostname is not None else ''
6548        self.id = id if id is not None else ''
6549        '''
6550         Unique identifier of the Resource.
6551        '''
6552        self.name = name if name is not None else ''
6553        '''
6554         Unique human-readable name of the Resource.
6555        '''
6556        self.password = password if password is not None else ''
6557        self.port = port if port is not None else 0
6558        self.port_override = port_override if port_override is not None else 0
6559        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6560        '''
6561         ID of the secret store containing credentials for this resource, if any.
6562        '''
6563        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6564        '''
6565         Tags is a map of key, value pairs.
6566        '''
6567        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6586    def to_dict(self):
6587        return {
6588            'bind_interface': self.bind_interface,
6589            'egress_filter': self.egress_filter,
6590            'healthcheck_namespace': self.healthcheck_namespace,
6591            'healthy': self.healthy,
6592            'hostname': self.hostname,
6593            'id': self.id,
6594            'name': self.name,
6595            'password': self.password,
6596            'port': self.port,
6597            'port_override': self.port_override,
6598            'secret_store_id': self.secret_store_id,
6599            'tags': self.tags,
6600            'username': self.username,
6601        }
@classmethod
def from_dict(cls, d)
6603    @classmethod
6604    def from_dict(cls, d):
6605        return cls(
6606            bind_interface=d.get('bind_interface'),
6607            egress_filter=d.get('egress_filter'),
6608            healthcheck_namespace=d.get('healthcheck_namespace'),
6609            healthy=d.get('healthy'),
6610            hostname=d.get('hostname'),
6611            id=d.get('id'),
6612            name=d.get('name'),
6613            password=d.get('password'),
6614            port=d.get('port'),
6615            port_override=d.get('port_override'),
6616            secret_store_id=d.get('secret_store_id'),
6617            tags=d.get('tags'),
6618            username=d.get('username'),
6619        )
class KubernetesServiceAccount:
6622class KubernetesServiceAccount:
6623    __slots__ = [
6624        'bind_interface',
6625        'egress_filter',
6626        'healthcheck_namespace',
6627        'healthy',
6628        'hostname',
6629        'id',
6630        'name',
6631        'port',
6632        'port_override',
6633        'remote_identity_group_id',
6634        'remote_identity_healthcheck_username',
6635        'secret_store_id',
6636        'tags',
6637        'token',
6638    ]
6639
6640    def __init__(
6641        self,
6642        bind_interface=None,
6643        egress_filter=None,
6644        healthcheck_namespace=None,
6645        healthy=None,
6646        hostname=None,
6647        id=None,
6648        name=None,
6649        port=None,
6650        port_override=None,
6651        remote_identity_group_id=None,
6652        remote_identity_healthcheck_username=None,
6653        secret_store_id=None,
6654        tags=None,
6655        token=None,
6656    ):
6657        self.bind_interface = bind_interface if bind_interface is not None else ''
6658        '''
6659         Bind interface
6660        '''
6661        self.egress_filter = egress_filter if egress_filter is not None else ''
6662        '''
6663         A filter applied to the routing logic to pin datasource to nodes.
6664        '''
6665        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6666        '''
6667         The path used to check the health of your connection.  Defaults to `default`.
6668        '''
6669        self.healthy = healthy if healthy is not None else False
6670        '''
6671         True if the datasource is reachable and the credentials are valid.
6672        '''
6673        self.hostname = hostname if hostname is not None else ''
6674        self.id = id if id is not None else ''
6675        '''
6676         Unique identifier of the Resource.
6677        '''
6678        self.name = name if name is not None else ''
6679        '''
6680         Unique human-readable name of the Resource.
6681        '''
6682        self.port = port if port is not None else 0
6683        self.port_override = port_override if port_override is not None else 0
6684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6685        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6686        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6687        '''
6688         ID of the secret store containing credentials for this resource, if any.
6689        '''
6690        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6691        '''
6692         Tags is a map of key, value pairs.
6693        '''
6694        self.token = token if token is not None else ''
6695
6696    def __repr__(self):
6697        return '<sdm.KubernetesServiceAccount ' + \
6698            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6699            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6700            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6701            'healthy: ' + repr(self.healthy) + ' ' +\
6702            'hostname: ' + repr(self.hostname) + ' ' +\
6703            'id: ' + repr(self.id) + ' ' +\
6704            'name: ' + repr(self.name) + ' ' +\
6705            'port: ' + repr(self.port) + ' ' +\
6706            'port_override: ' + repr(self.port_override) + ' ' +\
6707            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6708            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6709            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6710            'tags: ' + repr(self.tags) + ' ' +\
6711            'token: ' + repr(self.token) + ' ' +\
6712            '>'
6713
6714    def to_dict(self):
6715        return {
6716            'bind_interface': self.bind_interface,
6717            'egress_filter': self.egress_filter,
6718            'healthcheck_namespace': self.healthcheck_namespace,
6719            'healthy': self.healthy,
6720            'hostname': self.hostname,
6721            'id': self.id,
6722            'name': self.name,
6723            'port': self.port,
6724            'port_override': self.port_override,
6725            'remote_identity_group_id': self.remote_identity_group_id,
6726            'remote_identity_healthcheck_username':
6727            self.remote_identity_healthcheck_username,
6728            'secret_store_id': self.secret_store_id,
6729            'tags': self.tags,
6730            'token': self.token,
6731        }
6732
6733    @classmethod
6734    def from_dict(cls, d):
6735        return cls(
6736            bind_interface=d.get('bind_interface'),
6737            egress_filter=d.get('egress_filter'),
6738            healthcheck_namespace=d.get('healthcheck_namespace'),
6739            healthy=d.get('healthy'),
6740            hostname=d.get('hostname'),
6741            id=d.get('id'),
6742            name=d.get('name'),
6743            port=d.get('port'),
6744            port_override=d.get('port_override'),
6745            remote_identity_group_id=d.get('remote_identity_group_id'),
6746            remote_identity_healthcheck_username=d.get(
6747                'remote_identity_healthcheck_username'),
6748            secret_store_id=d.get('secret_store_id'),
6749            tags=d.get('tags'),
6750            token=d.get('token'),
6751        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6640    def __init__(
6641        self,
6642        bind_interface=None,
6643        egress_filter=None,
6644        healthcheck_namespace=None,
6645        healthy=None,
6646        hostname=None,
6647        id=None,
6648        name=None,
6649        port=None,
6650        port_override=None,
6651        remote_identity_group_id=None,
6652        remote_identity_healthcheck_username=None,
6653        secret_store_id=None,
6654        tags=None,
6655        token=None,
6656    ):
6657        self.bind_interface = bind_interface if bind_interface is not None else ''
6658        '''
6659         Bind interface
6660        '''
6661        self.egress_filter = egress_filter if egress_filter is not None else ''
6662        '''
6663         A filter applied to the routing logic to pin datasource to nodes.
6664        '''
6665        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6666        '''
6667         The path used to check the health of your connection.  Defaults to `default`.
6668        '''
6669        self.healthy = healthy if healthy is not None else False
6670        '''
6671         True if the datasource is reachable and the credentials are valid.
6672        '''
6673        self.hostname = hostname if hostname is not None else ''
6674        self.id = id if id is not None else ''
6675        '''
6676         Unique identifier of the Resource.
6677        '''
6678        self.name = name if name is not None else ''
6679        '''
6680         Unique human-readable name of the Resource.
6681        '''
6682        self.port = port if port is not None else 0
6683        self.port_override = port_override if port_override is not None else 0
6684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6685        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6686        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6687        '''
6688         ID of the secret store containing credentials for this resource, if any.
6689        '''
6690        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6691        '''
6692         Tags is a map of key, value pairs.
6693        '''
6694        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6714    def to_dict(self):
6715        return {
6716            'bind_interface': self.bind_interface,
6717            'egress_filter': self.egress_filter,
6718            'healthcheck_namespace': self.healthcheck_namespace,
6719            'healthy': self.healthy,
6720            'hostname': self.hostname,
6721            'id': self.id,
6722            'name': self.name,
6723            'port': self.port,
6724            'port_override': self.port_override,
6725            'remote_identity_group_id': self.remote_identity_group_id,
6726            'remote_identity_healthcheck_username':
6727            self.remote_identity_healthcheck_username,
6728            'secret_store_id': self.secret_store_id,
6729            'tags': self.tags,
6730            'token': self.token,
6731        }
@classmethod
def from_dict(cls, d)
6733    @classmethod
6734    def from_dict(cls, d):
6735        return cls(
6736            bind_interface=d.get('bind_interface'),
6737            egress_filter=d.get('egress_filter'),
6738            healthcheck_namespace=d.get('healthcheck_namespace'),
6739            healthy=d.get('healthy'),
6740            hostname=d.get('hostname'),
6741            id=d.get('id'),
6742            name=d.get('name'),
6743            port=d.get('port'),
6744            port_override=d.get('port_override'),
6745            remote_identity_group_id=d.get('remote_identity_group_id'),
6746            remote_identity_healthcheck_username=d.get(
6747                'remote_identity_healthcheck_username'),
6748            secret_store_id=d.get('secret_store_id'),
6749            tags=d.get('tags'),
6750            token=d.get('token'),
6751        )
class KubernetesServiceAccountUserImpersonation:
6754class KubernetesServiceAccountUserImpersonation:
6755    __slots__ = [
6756        'bind_interface',
6757        'egress_filter',
6758        'healthcheck_namespace',
6759        'healthy',
6760        'hostname',
6761        'id',
6762        'name',
6763        'port',
6764        'port_override',
6765        'secret_store_id',
6766        'tags',
6767        'token',
6768    ]
6769
6770    def __init__(
6771        self,
6772        bind_interface=None,
6773        egress_filter=None,
6774        healthcheck_namespace=None,
6775        healthy=None,
6776        hostname=None,
6777        id=None,
6778        name=None,
6779        port=None,
6780        port_override=None,
6781        secret_store_id=None,
6782        tags=None,
6783        token=None,
6784    ):
6785        self.bind_interface = bind_interface if bind_interface is not None else ''
6786        '''
6787         Bind interface
6788        '''
6789        self.egress_filter = egress_filter if egress_filter is not None else ''
6790        '''
6791         A filter applied to the routing logic to pin datasource to nodes.
6792        '''
6793        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6794        '''
6795         The path used to check the health of your connection.  Defaults to `default`.
6796        '''
6797        self.healthy = healthy if healthy is not None else False
6798        '''
6799         True if the datasource is reachable and the credentials are valid.
6800        '''
6801        self.hostname = hostname if hostname is not None else ''
6802        self.id = id if id is not None else ''
6803        '''
6804         Unique identifier of the Resource.
6805        '''
6806        self.name = name if name is not None else ''
6807        '''
6808         Unique human-readable name of the Resource.
6809        '''
6810        self.port = port if port is not None else 0
6811        self.port_override = port_override if port_override is not None else 0
6812        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6813        '''
6814         ID of the secret store containing credentials for this resource, if any.
6815        '''
6816        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6817        '''
6818         Tags is a map of key, value pairs.
6819        '''
6820        self.token = token if token is not None else ''
6821
6822    def __repr__(self):
6823        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6824            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6825            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6826            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6827            'healthy: ' + repr(self.healthy) + ' ' +\
6828            'hostname: ' + repr(self.hostname) + ' ' +\
6829            'id: ' + repr(self.id) + ' ' +\
6830            'name: ' + repr(self.name) + ' ' +\
6831            'port: ' + repr(self.port) + ' ' +\
6832            'port_override: ' + repr(self.port_override) + ' ' +\
6833            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6834            'tags: ' + repr(self.tags) + ' ' +\
6835            'token: ' + repr(self.token) + ' ' +\
6836            '>'
6837
6838    def to_dict(self):
6839        return {
6840            'bind_interface': self.bind_interface,
6841            'egress_filter': self.egress_filter,
6842            'healthcheck_namespace': self.healthcheck_namespace,
6843            'healthy': self.healthy,
6844            'hostname': self.hostname,
6845            'id': self.id,
6846            'name': self.name,
6847            'port': self.port,
6848            'port_override': self.port_override,
6849            'secret_store_id': self.secret_store_id,
6850            'tags': self.tags,
6851            'token': self.token,
6852        }
6853
6854    @classmethod
6855    def from_dict(cls, d):
6856        return cls(
6857            bind_interface=d.get('bind_interface'),
6858            egress_filter=d.get('egress_filter'),
6859            healthcheck_namespace=d.get('healthcheck_namespace'),
6860            healthy=d.get('healthy'),
6861            hostname=d.get('hostname'),
6862            id=d.get('id'),
6863            name=d.get('name'),
6864            port=d.get('port'),
6865            port_override=d.get('port_override'),
6866            secret_store_id=d.get('secret_store_id'),
6867            tags=d.get('tags'),
6868            token=d.get('token'),
6869        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6770    def __init__(
6771        self,
6772        bind_interface=None,
6773        egress_filter=None,
6774        healthcheck_namespace=None,
6775        healthy=None,
6776        hostname=None,
6777        id=None,
6778        name=None,
6779        port=None,
6780        port_override=None,
6781        secret_store_id=None,
6782        tags=None,
6783        token=None,
6784    ):
6785        self.bind_interface = bind_interface if bind_interface is not None else ''
6786        '''
6787         Bind interface
6788        '''
6789        self.egress_filter = egress_filter if egress_filter is not None else ''
6790        '''
6791         A filter applied to the routing logic to pin datasource to nodes.
6792        '''
6793        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6794        '''
6795         The path used to check the health of your connection.  Defaults to `default`.
6796        '''
6797        self.healthy = healthy if healthy is not None else False
6798        '''
6799         True if the datasource is reachable and the credentials are valid.
6800        '''
6801        self.hostname = hostname if hostname is not None else ''
6802        self.id = id if id is not None else ''
6803        '''
6804         Unique identifier of the Resource.
6805        '''
6806        self.name = name if name is not None else ''
6807        '''
6808         Unique human-readable name of the Resource.
6809        '''
6810        self.port = port if port is not None else 0
6811        self.port_override = port_override if port_override is not None else 0
6812        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6813        '''
6814         ID of the secret store containing credentials for this resource, if any.
6815        '''
6816        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6817        '''
6818         Tags is a map of key, value pairs.
6819        '''
6820        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6838    def to_dict(self):
6839        return {
6840            'bind_interface': self.bind_interface,
6841            'egress_filter': self.egress_filter,
6842            'healthcheck_namespace': self.healthcheck_namespace,
6843            'healthy': self.healthy,
6844            'hostname': self.hostname,
6845            'id': self.id,
6846            'name': self.name,
6847            'port': self.port,
6848            'port_override': self.port_override,
6849            'secret_store_id': self.secret_store_id,
6850            'tags': self.tags,
6851            'token': self.token,
6852        }
@classmethod
def from_dict(cls, d)
6854    @classmethod
6855    def from_dict(cls, d):
6856        return cls(
6857            bind_interface=d.get('bind_interface'),
6858            egress_filter=d.get('egress_filter'),
6859            healthcheck_namespace=d.get('healthcheck_namespace'),
6860            healthy=d.get('healthy'),
6861            hostname=d.get('hostname'),
6862            id=d.get('id'),
6863            name=d.get('name'),
6864            port=d.get('port'),
6865            port_override=d.get('port_override'),
6866            secret_store_id=d.get('secret_store_id'),
6867            tags=d.get('tags'),
6868            token=d.get('token'),
6869        )
class KubernetesUserImpersonation:
6872class KubernetesUserImpersonation:
6873    __slots__ = [
6874        'bind_interface',
6875        'certificate_authority',
6876        'client_certificate',
6877        'client_key',
6878        'egress_filter',
6879        'healthcheck_namespace',
6880        'healthy',
6881        'hostname',
6882        'id',
6883        'name',
6884        'port',
6885        'port_override',
6886        'secret_store_id',
6887        'tags',
6888    ]
6889
6890    def __init__(
6891        self,
6892        bind_interface=None,
6893        certificate_authority=None,
6894        client_certificate=None,
6895        client_key=None,
6896        egress_filter=None,
6897        healthcheck_namespace=None,
6898        healthy=None,
6899        hostname=None,
6900        id=None,
6901        name=None,
6902        port=None,
6903        port_override=None,
6904        secret_store_id=None,
6905        tags=None,
6906    ):
6907        self.bind_interface = bind_interface if bind_interface is not None else ''
6908        '''
6909         Bind interface
6910        '''
6911        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6912        self.client_certificate = client_certificate if client_certificate is not None else ''
6913        self.client_key = client_key if client_key is not None else ''
6914        self.egress_filter = egress_filter if egress_filter is not None else ''
6915        '''
6916         A filter applied to the routing logic to pin datasource to nodes.
6917        '''
6918        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6919        '''
6920         The path used to check the health of your connection.  Defaults to `default`.
6921        '''
6922        self.healthy = healthy if healthy is not None else False
6923        '''
6924         True if the datasource is reachable and the credentials are valid.
6925        '''
6926        self.hostname = hostname if hostname is not None else ''
6927        self.id = id if id is not None else ''
6928        '''
6929         Unique identifier of the Resource.
6930        '''
6931        self.name = name if name is not None else ''
6932        '''
6933         Unique human-readable name of the Resource.
6934        '''
6935        self.port = port if port is not None else 0
6936        self.port_override = port_override if port_override is not None else 0
6937        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6938        '''
6939         ID of the secret store containing credentials for this resource, if any.
6940        '''
6941        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6942        '''
6943         Tags is a map of key, value pairs.
6944        '''
6945
6946    def __repr__(self):
6947        return '<sdm.KubernetesUserImpersonation ' + \
6948            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6949            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6950            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6951            'client_key: ' + repr(self.client_key) + ' ' +\
6952            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6953            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6954            'healthy: ' + repr(self.healthy) + ' ' +\
6955            'hostname: ' + repr(self.hostname) + ' ' +\
6956            'id: ' + repr(self.id) + ' ' +\
6957            'name: ' + repr(self.name) + ' ' +\
6958            'port: ' + repr(self.port) + ' ' +\
6959            'port_override: ' + repr(self.port_override) + ' ' +\
6960            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6961            'tags: ' + repr(self.tags) + ' ' +\
6962            '>'
6963
6964    def to_dict(self):
6965        return {
6966            'bind_interface': self.bind_interface,
6967            'certificate_authority': self.certificate_authority,
6968            'client_certificate': self.client_certificate,
6969            'client_key': self.client_key,
6970            'egress_filter': self.egress_filter,
6971            'healthcheck_namespace': self.healthcheck_namespace,
6972            'healthy': self.healthy,
6973            'hostname': self.hostname,
6974            'id': self.id,
6975            'name': self.name,
6976            'port': self.port,
6977            'port_override': self.port_override,
6978            'secret_store_id': self.secret_store_id,
6979            'tags': self.tags,
6980        }
6981
6982    @classmethod
6983    def from_dict(cls, d):
6984        return cls(
6985            bind_interface=d.get('bind_interface'),
6986            certificate_authority=d.get('certificate_authority'),
6987            client_certificate=d.get('client_certificate'),
6988            client_key=d.get('client_key'),
6989            egress_filter=d.get('egress_filter'),
6990            healthcheck_namespace=d.get('healthcheck_namespace'),
6991            healthy=d.get('healthy'),
6992            hostname=d.get('hostname'),
6993            id=d.get('id'),
6994            name=d.get('name'),
6995            port=d.get('port'),
6996            port_override=d.get('port_override'),
6997            secret_store_id=d.get('secret_store_id'),
6998            tags=d.get('tags'),
6999        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6890    def __init__(
6891        self,
6892        bind_interface=None,
6893        certificate_authority=None,
6894        client_certificate=None,
6895        client_key=None,
6896        egress_filter=None,
6897        healthcheck_namespace=None,
6898        healthy=None,
6899        hostname=None,
6900        id=None,
6901        name=None,
6902        port=None,
6903        port_override=None,
6904        secret_store_id=None,
6905        tags=None,
6906    ):
6907        self.bind_interface = bind_interface if bind_interface is not None else ''
6908        '''
6909         Bind interface
6910        '''
6911        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6912        self.client_certificate = client_certificate if client_certificate is not None else ''
6913        self.client_key = client_key if client_key is not None else ''
6914        self.egress_filter = egress_filter if egress_filter is not None else ''
6915        '''
6916         A filter applied to the routing logic to pin datasource to nodes.
6917        '''
6918        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6919        '''
6920         The path used to check the health of your connection.  Defaults to `default`.
6921        '''
6922        self.healthy = healthy if healthy is not None else False
6923        '''
6924         True if the datasource is reachable and the credentials are valid.
6925        '''
6926        self.hostname = hostname if hostname is not None else ''
6927        self.id = id if id is not None else ''
6928        '''
6929         Unique identifier of the Resource.
6930        '''
6931        self.name = name if name is not None else ''
6932        '''
6933         Unique human-readable name of the Resource.
6934        '''
6935        self.port = port if port is not None else 0
6936        self.port_override = port_override if port_override is not None else 0
6937        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6938        '''
6939         ID of the secret store containing credentials for this resource, if any.
6940        '''
6941        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6942        '''
6943         Tags is a map of key, value pairs.
6944        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6964    def to_dict(self):
6965        return {
6966            'bind_interface': self.bind_interface,
6967            'certificate_authority': self.certificate_authority,
6968            'client_certificate': self.client_certificate,
6969            'client_key': self.client_key,
6970            'egress_filter': self.egress_filter,
6971            'healthcheck_namespace': self.healthcheck_namespace,
6972            'healthy': self.healthy,
6973            'hostname': self.hostname,
6974            'id': self.id,
6975            'name': self.name,
6976            'port': self.port,
6977            'port_override': self.port_override,
6978            'secret_store_id': self.secret_store_id,
6979            'tags': self.tags,
6980        }
@classmethod
def from_dict(cls, d)
6982    @classmethod
6983    def from_dict(cls, d):
6984        return cls(
6985            bind_interface=d.get('bind_interface'),
6986            certificate_authority=d.get('certificate_authority'),
6987            client_certificate=d.get('client_certificate'),
6988            client_key=d.get('client_key'),
6989            egress_filter=d.get('egress_filter'),
6990            healthcheck_namespace=d.get('healthcheck_namespace'),
6991            healthy=d.get('healthy'),
6992            hostname=d.get('hostname'),
6993            id=d.get('id'),
6994            name=d.get('name'),
6995            port=d.get('port'),
6996            port_override=d.get('port_override'),
6997            secret_store_id=d.get('secret_store_id'),
6998            tags=d.get('tags'),
6999        )
class MTLSMysql:
7002class MTLSMysql:
7003    '''
7004    MTLSMysql is currently unstable, and its API may change, or it may be removed,
7005    without a major version bump.
7006    '''
7007    __slots__ = [
7008        'bind_interface',
7009        'certificate_authority',
7010        'client_certificate',
7011        'client_key',
7012        'database',
7013        'egress_filter',
7014        'healthy',
7015        'hostname',
7016        'id',
7017        'name',
7018        'password',
7019        'port',
7020        'port_override',
7021        'secret_store_id',
7022        'server_name',
7023        'tags',
7024        'username',
7025    ]
7026
7027    def __init__(
7028        self,
7029        bind_interface=None,
7030        certificate_authority=None,
7031        client_certificate=None,
7032        client_key=None,
7033        database=None,
7034        egress_filter=None,
7035        healthy=None,
7036        hostname=None,
7037        id=None,
7038        name=None,
7039        password=None,
7040        port=None,
7041        port_override=None,
7042        secret_store_id=None,
7043        server_name=None,
7044        tags=None,
7045        username=None,
7046    ):
7047        self.bind_interface = bind_interface if bind_interface is not None else ''
7048        '''
7049         Bind interface
7050        '''
7051        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7052        self.client_certificate = client_certificate if client_certificate is not None else ''
7053        self.client_key = client_key if client_key is not None else ''
7054        self.database = database if database is not None else ''
7055        self.egress_filter = egress_filter if egress_filter is not None else ''
7056        '''
7057         A filter applied to the routing logic to pin datasource to nodes.
7058        '''
7059        self.healthy = healthy if healthy is not None else False
7060        '''
7061         True if the datasource is reachable and the credentials are valid.
7062        '''
7063        self.hostname = hostname if hostname is not None else ''
7064        self.id = id if id is not None else ''
7065        '''
7066         Unique identifier of the Resource.
7067        '''
7068        self.name = name if name is not None else ''
7069        '''
7070         Unique human-readable name of the Resource.
7071        '''
7072        self.password = password if password is not None else ''
7073        self.port = port if port is not None else 0
7074        self.port_override = port_override if port_override is not None else 0
7075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7076        '''
7077         ID of the secret store containing credentials for this resource, if any.
7078        '''
7079        self.server_name = server_name if server_name is not None else ''
7080        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7081        '''
7082         Tags is a map of key, value pairs.
7083        '''
7084        self.username = username if username is not None else ''
7085
7086    def __repr__(self):
7087        return '<sdm.MTLSMysql ' + \
7088            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7089            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7090            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7091            'client_key: ' + repr(self.client_key) + ' ' +\
7092            'database: ' + repr(self.database) + ' ' +\
7093            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7094            'healthy: ' + repr(self.healthy) + ' ' +\
7095            'hostname: ' + repr(self.hostname) + ' ' +\
7096            'id: ' + repr(self.id) + ' ' +\
7097            'name: ' + repr(self.name) + ' ' +\
7098            'password: ' + repr(self.password) + ' ' +\
7099            'port: ' + repr(self.port) + ' ' +\
7100            'port_override: ' + repr(self.port_override) + ' ' +\
7101            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7102            'server_name: ' + repr(self.server_name) + ' ' +\
7103            'tags: ' + repr(self.tags) + ' ' +\
7104            'username: ' + repr(self.username) + ' ' +\
7105            '>'
7106
7107    def to_dict(self):
7108        return {
7109            'bind_interface': self.bind_interface,
7110            'certificate_authority': self.certificate_authority,
7111            'client_certificate': self.client_certificate,
7112            'client_key': self.client_key,
7113            'database': self.database,
7114            'egress_filter': self.egress_filter,
7115            'healthy': self.healthy,
7116            'hostname': self.hostname,
7117            'id': self.id,
7118            'name': self.name,
7119            'password': self.password,
7120            'port': self.port,
7121            'port_override': self.port_override,
7122            'secret_store_id': self.secret_store_id,
7123            'server_name': self.server_name,
7124            'tags': self.tags,
7125            'username': self.username,
7126        }
7127
7128    @classmethod
7129    def from_dict(cls, d):
7130        return cls(
7131            bind_interface=d.get('bind_interface'),
7132            certificate_authority=d.get('certificate_authority'),
7133            client_certificate=d.get('client_certificate'),
7134            client_key=d.get('client_key'),
7135            database=d.get('database'),
7136            egress_filter=d.get('egress_filter'),
7137            healthy=d.get('healthy'),
7138            hostname=d.get('hostname'),
7139            id=d.get('id'),
7140            name=d.get('name'),
7141            password=d.get('password'),
7142            port=d.get('port'),
7143            port_override=d.get('port_override'),
7144            secret_store_id=d.get('secret_store_id'),
7145            server_name=d.get('server_name'),
7146            tags=d.get('tags'),
7147            username=d.get('username'),
7148        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7027    def __init__(
7028        self,
7029        bind_interface=None,
7030        certificate_authority=None,
7031        client_certificate=None,
7032        client_key=None,
7033        database=None,
7034        egress_filter=None,
7035        healthy=None,
7036        hostname=None,
7037        id=None,
7038        name=None,
7039        password=None,
7040        port=None,
7041        port_override=None,
7042        secret_store_id=None,
7043        server_name=None,
7044        tags=None,
7045        username=None,
7046    ):
7047        self.bind_interface = bind_interface if bind_interface is not None else ''
7048        '''
7049         Bind interface
7050        '''
7051        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7052        self.client_certificate = client_certificate if client_certificate is not None else ''
7053        self.client_key = client_key if client_key is not None else ''
7054        self.database = database if database is not None else ''
7055        self.egress_filter = egress_filter if egress_filter is not None else ''
7056        '''
7057         A filter applied to the routing logic to pin datasource to nodes.
7058        '''
7059        self.healthy = healthy if healthy is not None else False
7060        '''
7061         True if the datasource is reachable and the credentials are valid.
7062        '''
7063        self.hostname = hostname if hostname is not None else ''
7064        self.id = id if id is not None else ''
7065        '''
7066         Unique identifier of the Resource.
7067        '''
7068        self.name = name if name is not None else ''
7069        '''
7070         Unique human-readable name of the Resource.
7071        '''
7072        self.password = password if password is not None else ''
7073        self.port = port if port is not None else 0
7074        self.port_override = port_override if port_override is not None else 0
7075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7076        '''
7077         ID of the secret store containing credentials for this resource, if any.
7078        '''
7079        self.server_name = server_name if server_name is not None else ''
7080        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7081        '''
7082         Tags is a map of key, value pairs.
7083        '''
7084        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7107    def to_dict(self):
7108        return {
7109            'bind_interface': self.bind_interface,
7110            'certificate_authority': self.certificate_authority,
7111            'client_certificate': self.client_certificate,
7112            'client_key': self.client_key,
7113            'database': self.database,
7114            'egress_filter': self.egress_filter,
7115            'healthy': self.healthy,
7116            'hostname': self.hostname,
7117            'id': self.id,
7118            'name': self.name,
7119            'password': self.password,
7120            'port': self.port,
7121            'port_override': self.port_override,
7122            'secret_store_id': self.secret_store_id,
7123            'server_name': self.server_name,
7124            'tags': self.tags,
7125            'username': self.username,
7126        }
@classmethod
def from_dict(cls, d)
7128    @classmethod
7129    def from_dict(cls, d):
7130        return cls(
7131            bind_interface=d.get('bind_interface'),
7132            certificate_authority=d.get('certificate_authority'),
7133            client_certificate=d.get('client_certificate'),
7134            client_key=d.get('client_key'),
7135            database=d.get('database'),
7136            egress_filter=d.get('egress_filter'),
7137            healthy=d.get('healthy'),
7138            hostname=d.get('hostname'),
7139            id=d.get('id'),
7140            name=d.get('name'),
7141            password=d.get('password'),
7142            port=d.get('port'),
7143            port_override=d.get('port_override'),
7144            secret_store_id=d.get('secret_store_id'),
7145            server_name=d.get('server_name'),
7146            tags=d.get('tags'),
7147            username=d.get('username'),
7148        )
class MTLSPostgres:
7151class MTLSPostgres:
7152    __slots__ = [
7153        'bind_interface',
7154        'certificate_authority',
7155        'client_certificate',
7156        'client_key',
7157        'database',
7158        'egress_filter',
7159        'healthy',
7160        'hostname',
7161        'id',
7162        'name',
7163        'override_database',
7164        'password',
7165        'port',
7166        'port_override',
7167        'secret_store_id',
7168        'server_name',
7169        'tags',
7170        'username',
7171    ]
7172
7173    def __init__(
7174        self,
7175        bind_interface=None,
7176        certificate_authority=None,
7177        client_certificate=None,
7178        client_key=None,
7179        database=None,
7180        egress_filter=None,
7181        healthy=None,
7182        hostname=None,
7183        id=None,
7184        name=None,
7185        override_database=None,
7186        password=None,
7187        port=None,
7188        port_override=None,
7189        secret_store_id=None,
7190        server_name=None,
7191        tags=None,
7192        username=None,
7193    ):
7194        self.bind_interface = bind_interface if bind_interface is not None else ''
7195        '''
7196         Bind interface
7197        '''
7198        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7199        self.client_certificate = client_certificate if client_certificate is not None else ''
7200        self.client_key = client_key if client_key is not None else ''
7201        self.database = database if database is not None else ''
7202        self.egress_filter = egress_filter if egress_filter is not None else ''
7203        '''
7204         A filter applied to the routing logic to pin datasource to nodes.
7205        '''
7206        self.healthy = healthy if healthy is not None else False
7207        '''
7208         True if the datasource is reachable and the credentials are valid.
7209        '''
7210        self.hostname = hostname if hostname is not None else ''
7211        self.id = id if id is not None else ''
7212        '''
7213         Unique identifier of the Resource.
7214        '''
7215        self.name = name if name is not None else ''
7216        '''
7217         Unique human-readable name of the Resource.
7218        '''
7219        self.override_database = override_database if override_database is not None else False
7220        self.password = password if password is not None else ''
7221        self.port = port if port is not None else 0
7222        self.port_override = port_override if port_override is not None else 0
7223        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7224        '''
7225         ID of the secret store containing credentials for this resource, if any.
7226        '''
7227        self.server_name = server_name if server_name is not None else ''
7228        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7229        '''
7230         Tags is a map of key, value pairs.
7231        '''
7232        self.username = username if username is not None else ''
7233
7234    def __repr__(self):
7235        return '<sdm.MTLSPostgres ' + \
7236            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7237            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7238            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7239            'client_key: ' + repr(self.client_key) + ' ' +\
7240            'database: ' + repr(self.database) + ' ' +\
7241            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7242            'healthy: ' + repr(self.healthy) + ' ' +\
7243            'hostname: ' + repr(self.hostname) + ' ' +\
7244            'id: ' + repr(self.id) + ' ' +\
7245            'name: ' + repr(self.name) + ' ' +\
7246            'override_database: ' + repr(self.override_database) + ' ' +\
7247            'password: ' + repr(self.password) + ' ' +\
7248            'port: ' + repr(self.port) + ' ' +\
7249            'port_override: ' + repr(self.port_override) + ' ' +\
7250            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7251            'server_name: ' + repr(self.server_name) + ' ' +\
7252            'tags: ' + repr(self.tags) + ' ' +\
7253            'username: ' + repr(self.username) + ' ' +\
7254            '>'
7255
7256    def to_dict(self):
7257        return {
7258            'bind_interface': self.bind_interface,
7259            'certificate_authority': self.certificate_authority,
7260            'client_certificate': self.client_certificate,
7261            'client_key': self.client_key,
7262            'database': self.database,
7263            'egress_filter': self.egress_filter,
7264            'healthy': self.healthy,
7265            'hostname': self.hostname,
7266            'id': self.id,
7267            'name': self.name,
7268            'override_database': self.override_database,
7269            'password': self.password,
7270            'port': self.port,
7271            'port_override': self.port_override,
7272            'secret_store_id': self.secret_store_id,
7273            'server_name': self.server_name,
7274            'tags': self.tags,
7275            'username': self.username,
7276        }
7277
7278    @classmethod
7279    def from_dict(cls, d):
7280        return cls(
7281            bind_interface=d.get('bind_interface'),
7282            certificate_authority=d.get('certificate_authority'),
7283            client_certificate=d.get('client_certificate'),
7284            client_key=d.get('client_key'),
7285            database=d.get('database'),
7286            egress_filter=d.get('egress_filter'),
7287            healthy=d.get('healthy'),
7288            hostname=d.get('hostname'),
7289            id=d.get('id'),
7290            name=d.get('name'),
7291            override_database=d.get('override_database'),
7292            password=d.get('password'),
7293            port=d.get('port'),
7294            port_override=d.get('port_override'),
7295            secret_store_id=d.get('secret_store_id'),
7296            server_name=d.get('server_name'),
7297            tags=d.get('tags'),
7298            username=d.get('username'),
7299        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7173    def __init__(
7174        self,
7175        bind_interface=None,
7176        certificate_authority=None,
7177        client_certificate=None,
7178        client_key=None,
7179        database=None,
7180        egress_filter=None,
7181        healthy=None,
7182        hostname=None,
7183        id=None,
7184        name=None,
7185        override_database=None,
7186        password=None,
7187        port=None,
7188        port_override=None,
7189        secret_store_id=None,
7190        server_name=None,
7191        tags=None,
7192        username=None,
7193    ):
7194        self.bind_interface = bind_interface if bind_interface is not None else ''
7195        '''
7196         Bind interface
7197        '''
7198        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7199        self.client_certificate = client_certificate if client_certificate is not None else ''
7200        self.client_key = client_key if client_key is not None else ''
7201        self.database = database if database is not None else ''
7202        self.egress_filter = egress_filter if egress_filter is not None else ''
7203        '''
7204         A filter applied to the routing logic to pin datasource to nodes.
7205        '''
7206        self.healthy = healthy if healthy is not None else False
7207        '''
7208         True if the datasource is reachable and the credentials are valid.
7209        '''
7210        self.hostname = hostname if hostname is not None else ''
7211        self.id = id if id is not None else ''
7212        '''
7213         Unique identifier of the Resource.
7214        '''
7215        self.name = name if name is not None else ''
7216        '''
7217         Unique human-readable name of the Resource.
7218        '''
7219        self.override_database = override_database if override_database is not None else False
7220        self.password = password if password is not None else ''
7221        self.port = port if port is not None else 0
7222        self.port_override = port_override if port_override is not None else 0
7223        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7224        '''
7225         ID of the secret store containing credentials for this resource, if any.
7226        '''
7227        self.server_name = server_name if server_name is not None else ''
7228        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7229        '''
7230         Tags is a map of key, value pairs.
7231        '''
7232        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7256    def to_dict(self):
7257        return {
7258            'bind_interface': self.bind_interface,
7259            'certificate_authority': self.certificate_authority,
7260            'client_certificate': self.client_certificate,
7261            'client_key': self.client_key,
7262            'database': self.database,
7263            'egress_filter': self.egress_filter,
7264            'healthy': self.healthy,
7265            'hostname': self.hostname,
7266            'id': self.id,
7267            'name': self.name,
7268            'override_database': self.override_database,
7269            'password': self.password,
7270            'port': self.port,
7271            'port_override': self.port_override,
7272            'secret_store_id': self.secret_store_id,
7273            'server_name': self.server_name,
7274            'tags': self.tags,
7275            'username': self.username,
7276        }
@classmethod
def from_dict(cls, d)
7278    @classmethod
7279    def from_dict(cls, d):
7280        return cls(
7281            bind_interface=d.get('bind_interface'),
7282            certificate_authority=d.get('certificate_authority'),
7283            client_certificate=d.get('client_certificate'),
7284            client_key=d.get('client_key'),
7285            database=d.get('database'),
7286            egress_filter=d.get('egress_filter'),
7287            healthy=d.get('healthy'),
7288            hostname=d.get('hostname'),
7289            id=d.get('id'),
7290            name=d.get('name'),
7291            override_database=d.get('override_database'),
7292            password=d.get('password'),
7293            port=d.get('port'),
7294            port_override=d.get('port_override'),
7295            secret_store_id=d.get('secret_store_id'),
7296            server_name=d.get('server_name'),
7297            tags=d.get('tags'),
7298            username=d.get('username'),
7299        )
class Maria:
7302class Maria:
7303    __slots__ = [
7304        'bind_interface',
7305        'database',
7306        'egress_filter',
7307        'healthy',
7308        'hostname',
7309        'id',
7310        'name',
7311        'password',
7312        'port',
7313        'port_override',
7314        'secret_store_id',
7315        'tags',
7316        'username',
7317    ]
7318
7319    def __init__(
7320        self,
7321        bind_interface=None,
7322        database=None,
7323        egress_filter=None,
7324        healthy=None,
7325        hostname=None,
7326        id=None,
7327        name=None,
7328        password=None,
7329        port=None,
7330        port_override=None,
7331        secret_store_id=None,
7332        tags=None,
7333        username=None,
7334    ):
7335        self.bind_interface = bind_interface if bind_interface is not None else ''
7336        '''
7337         Bind interface
7338        '''
7339        self.database = database if database is not None else ''
7340        self.egress_filter = egress_filter if egress_filter is not None else ''
7341        '''
7342         A filter applied to the routing logic to pin datasource to nodes.
7343        '''
7344        self.healthy = healthy if healthy is not None else False
7345        '''
7346         True if the datasource is reachable and the credentials are valid.
7347        '''
7348        self.hostname = hostname if hostname is not None else ''
7349        self.id = id if id is not None else ''
7350        '''
7351         Unique identifier of the Resource.
7352        '''
7353        self.name = name if name is not None else ''
7354        '''
7355         Unique human-readable name of the Resource.
7356        '''
7357        self.password = password if password is not None else ''
7358        self.port = port if port is not None else 0
7359        self.port_override = port_override if port_override is not None else 0
7360        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7361        '''
7362         ID of the secret store containing credentials for this resource, if any.
7363        '''
7364        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7365        '''
7366         Tags is a map of key, value pairs.
7367        '''
7368        self.username = username if username is not None else ''
7369
7370    def __repr__(self):
7371        return '<sdm.Maria ' + \
7372            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7373            'database: ' + repr(self.database) + ' ' +\
7374            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7375            'healthy: ' + repr(self.healthy) + ' ' +\
7376            'hostname: ' + repr(self.hostname) + ' ' +\
7377            'id: ' + repr(self.id) + ' ' +\
7378            'name: ' + repr(self.name) + ' ' +\
7379            'password: ' + repr(self.password) + ' ' +\
7380            'port: ' + repr(self.port) + ' ' +\
7381            'port_override: ' + repr(self.port_override) + ' ' +\
7382            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7383            'tags: ' + repr(self.tags) + ' ' +\
7384            'username: ' + repr(self.username) + ' ' +\
7385            '>'
7386
7387    def to_dict(self):
7388        return {
7389            'bind_interface': self.bind_interface,
7390            'database': self.database,
7391            'egress_filter': self.egress_filter,
7392            'healthy': self.healthy,
7393            'hostname': self.hostname,
7394            'id': self.id,
7395            'name': self.name,
7396            'password': self.password,
7397            'port': self.port,
7398            'port_override': self.port_override,
7399            'secret_store_id': self.secret_store_id,
7400            'tags': self.tags,
7401            'username': self.username,
7402        }
7403
7404    @classmethod
7405    def from_dict(cls, d):
7406        return cls(
7407            bind_interface=d.get('bind_interface'),
7408            database=d.get('database'),
7409            egress_filter=d.get('egress_filter'),
7410            healthy=d.get('healthy'),
7411            hostname=d.get('hostname'),
7412            id=d.get('id'),
7413            name=d.get('name'),
7414            password=d.get('password'),
7415            port=d.get('port'),
7416            port_override=d.get('port_override'),
7417            secret_store_id=d.get('secret_store_id'),
7418            tags=d.get('tags'),
7419            username=d.get('username'),
7420        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7319    def __init__(
7320        self,
7321        bind_interface=None,
7322        database=None,
7323        egress_filter=None,
7324        healthy=None,
7325        hostname=None,
7326        id=None,
7327        name=None,
7328        password=None,
7329        port=None,
7330        port_override=None,
7331        secret_store_id=None,
7332        tags=None,
7333        username=None,
7334    ):
7335        self.bind_interface = bind_interface if bind_interface is not None else ''
7336        '''
7337         Bind interface
7338        '''
7339        self.database = database if database is not None else ''
7340        self.egress_filter = egress_filter if egress_filter is not None else ''
7341        '''
7342         A filter applied to the routing logic to pin datasource to nodes.
7343        '''
7344        self.healthy = healthy if healthy is not None else False
7345        '''
7346         True if the datasource is reachable and the credentials are valid.
7347        '''
7348        self.hostname = hostname if hostname is not None else ''
7349        self.id = id if id is not None else ''
7350        '''
7351         Unique identifier of the Resource.
7352        '''
7353        self.name = name if name is not None else ''
7354        '''
7355         Unique human-readable name of the Resource.
7356        '''
7357        self.password = password if password is not None else ''
7358        self.port = port if port is not None else 0
7359        self.port_override = port_override if port_override is not None else 0
7360        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7361        '''
7362         ID of the secret store containing credentials for this resource, if any.
7363        '''
7364        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7365        '''
7366         Tags is a map of key, value pairs.
7367        '''
7368        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7387    def to_dict(self):
7388        return {
7389            'bind_interface': self.bind_interface,
7390            'database': self.database,
7391            'egress_filter': self.egress_filter,
7392            'healthy': self.healthy,
7393            'hostname': self.hostname,
7394            'id': self.id,
7395            'name': self.name,
7396            'password': self.password,
7397            'port': self.port,
7398            'port_override': self.port_override,
7399            'secret_store_id': self.secret_store_id,
7400            'tags': self.tags,
7401            'username': self.username,
7402        }
@classmethod
def from_dict(cls, d)
7404    @classmethod
7405    def from_dict(cls, d):
7406        return cls(
7407            bind_interface=d.get('bind_interface'),
7408            database=d.get('database'),
7409            egress_filter=d.get('egress_filter'),
7410            healthy=d.get('healthy'),
7411            hostname=d.get('hostname'),
7412            id=d.get('id'),
7413            name=d.get('name'),
7414            password=d.get('password'),
7415            port=d.get('port'),
7416            port_override=d.get('port_override'),
7417            secret_store_id=d.get('secret_store_id'),
7418            tags=d.get('tags'),
7419            username=d.get('username'),
7420        )
class Memcached:
7423class Memcached:
7424    __slots__ = [
7425        'bind_interface',
7426        'egress_filter',
7427        'healthy',
7428        'hostname',
7429        'id',
7430        'name',
7431        'port',
7432        'port_override',
7433        'secret_store_id',
7434        'tags',
7435    ]
7436
7437    def __init__(
7438        self,
7439        bind_interface=None,
7440        egress_filter=None,
7441        healthy=None,
7442        hostname=None,
7443        id=None,
7444        name=None,
7445        port=None,
7446        port_override=None,
7447        secret_store_id=None,
7448        tags=None,
7449    ):
7450        self.bind_interface = bind_interface if bind_interface is not None else ''
7451        '''
7452         Bind interface
7453        '''
7454        self.egress_filter = egress_filter if egress_filter is not None else ''
7455        '''
7456         A filter applied to the routing logic to pin datasource to nodes.
7457        '''
7458        self.healthy = healthy if healthy is not None else False
7459        '''
7460         True if the datasource is reachable and the credentials are valid.
7461        '''
7462        self.hostname = hostname if hostname is not None else ''
7463        self.id = id if id is not None else ''
7464        '''
7465         Unique identifier of the Resource.
7466        '''
7467        self.name = name if name is not None else ''
7468        '''
7469         Unique human-readable name of the Resource.
7470        '''
7471        self.port = port if port is not None else 0
7472        self.port_override = port_override if port_override is not None else 0
7473        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7474        '''
7475         ID of the secret store containing credentials for this resource, if any.
7476        '''
7477        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7478        '''
7479         Tags is a map of key, value pairs.
7480        '''
7481
7482    def __repr__(self):
7483        return '<sdm.Memcached ' + \
7484            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7485            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7486            'healthy: ' + repr(self.healthy) + ' ' +\
7487            'hostname: ' + repr(self.hostname) + ' ' +\
7488            'id: ' + repr(self.id) + ' ' +\
7489            'name: ' + repr(self.name) + ' ' +\
7490            'port: ' + repr(self.port) + ' ' +\
7491            'port_override: ' + repr(self.port_override) + ' ' +\
7492            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7493            'tags: ' + repr(self.tags) + ' ' +\
7494            '>'
7495
7496    def to_dict(self):
7497        return {
7498            'bind_interface': self.bind_interface,
7499            'egress_filter': self.egress_filter,
7500            'healthy': self.healthy,
7501            'hostname': self.hostname,
7502            'id': self.id,
7503            'name': self.name,
7504            'port': self.port,
7505            'port_override': self.port_override,
7506            'secret_store_id': self.secret_store_id,
7507            'tags': self.tags,
7508        }
7509
7510    @classmethod
7511    def from_dict(cls, d):
7512        return cls(
7513            bind_interface=d.get('bind_interface'),
7514            egress_filter=d.get('egress_filter'),
7515            healthy=d.get('healthy'),
7516            hostname=d.get('hostname'),
7517            id=d.get('id'),
7518            name=d.get('name'),
7519            port=d.get('port'),
7520            port_override=d.get('port_override'),
7521            secret_store_id=d.get('secret_store_id'),
7522            tags=d.get('tags'),
7523        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7437    def __init__(
7438        self,
7439        bind_interface=None,
7440        egress_filter=None,
7441        healthy=None,
7442        hostname=None,
7443        id=None,
7444        name=None,
7445        port=None,
7446        port_override=None,
7447        secret_store_id=None,
7448        tags=None,
7449    ):
7450        self.bind_interface = bind_interface if bind_interface is not None else ''
7451        '''
7452         Bind interface
7453        '''
7454        self.egress_filter = egress_filter if egress_filter is not None else ''
7455        '''
7456         A filter applied to the routing logic to pin datasource to nodes.
7457        '''
7458        self.healthy = healthy if healthy is not None else False
7459        '''
7460         True if the datasource is reachable and the credentials are valid.
7461        '''
7462        self.hostname = hostname if hostname is not None else ''
7463        self.id = id if id is not None else ''
7464        '''
7465         Unique identifier of the Resource.
7466        '''
7467        self.name = name if name is not None else ''
7468        '''
7469         Unique human-readable name of the Resource.
7470        '''
7471        self.port = port if port is not None else 0
7472        self.port_override = port_override if port_override is not None else 0
7473        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7474        '''
7475         ID of the secret store containing credentials for this resource, if any.
7476        '''
7477        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7478        '''
7479         Tags is a map of key, value pairs.
7480        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7496    def to_dict(self):
7497        return {
7498            'bind_interface': self.bind_interface,
7499            'egress_filter': self.egress_filter,
7500            'healthy': self.healthy,
7501            'hostname': self.hostname,
7502            'id': self.id,
7503            'name': self.name,
7504            'port': self.port,
7505            'port_override': self.port_override,
7506            'secret_store_id': self.secret_store_id,
7507            'tags': self.tags,
7508        }
@classmethod
def from_dict(cls, d)
7510    @classmethod
7511    def from_dict(cls, d):
7512        return cls(
7513            bind_interface=d.get('bind_interface'),
7514            egress_filter=d.get('egress_filter'),
7515            healthy=d.get('healthy'),
7516            hostname=d.get('hostname'),
7517            id=d.get('id'),
7518            name=d.get('name'),
7519            port=d.get('port'),
7520            port_override=d.get('port_override'),
7521            secret_store_id=d.get('secret_store_id'),
7522            tags=d.get('tags'),
7523        )
class Memsql:
7526class Memsql:
7527    __slots__ = [
7528        'bind_interface',
7529        'database',
7530        'egress_filter',
7531        'healthy',
7532        'hostname',
7533        'id',
7534        'name',
7535        'password',
7536        'port',
7537        'port_override',
7538        'secret_store_id',
7539        'tags',
7540        'username',
7541    ]
7542
7543    def __init__(
7544        self,
7545        bind_interface=None,
7546        database=None,
7547        egress_filter=None,
7548        healthy=None,
7549        hostname=None,
7550        id=None,
7551        name=None,
7552        password=None,
7553        port=None,
7554        port_override=None,
7555        secret_store_id=None,
7556        tags=None,
7557        username=None,
7558    ):
7559        self.bind_interface = bind_interface if bind_interface is not None else ''
7560        '''
7561         Bind interface
7562        '''
7563        self.database = database if database is not None else ''
7564        self.egress_filter = egress_filter if egress_filter is not None else ''
7565        '''
7566         A filter applied to the routing logic to pin datasource to nodes.
7567        '''
7568        self.healthy = healthy if healthy is not None else False
7569        '''
7570         True if the datasource is reachable and the credentials are valid.
7571        '''
7572        self.hostname = hostname if hostname is not None else ''
7573        self.id = id if id is not None else ''
7574        '''
7575         Unique identifier of the Resource.
7576        '''
7577        self.name = name if name is not None else ''
7578        '''
7579         Unique human-readable name of the Resource.
7580        '''
7581        self.password = password if password is not None else ''
7582        self.port = port if port is not None else 0
7583        self.port_override = port_override if port_override is not None else 0
7584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7585        '''
7586         ID of the secret store containing credentials for this resource, if any.
7587        '''
7588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7589        '''
7590         Tags is a map of key, value pairs.
7591        '''
7592        self.username = username if username is not None else ''
7593
7594    def __repr__(self):
7595        return '<sdm.Memsql ' + \
7596            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7597            'database: ' + repr(self.database) + ' ' +\
7598            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7599            'healthy: ' + repr(self.healthy) + ' ' +\
7600            'hostname: ' + repr(self.hostname) + ' ' +\
7601            'id: ' + repr(self.id) + ' ' +\
7602            'name: ' + repr(self.name) + ' ' +\
7603            'password: ' + repr(self.password) + ' ' +\
7604            'port: ' + repr(self.port) + ' ' +\
7605            'port_override: ' + repr(self.port_override) + ' ' +\
7606            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7607            'tags: ' + repr(self.tags) + ' ' +\
7608            'username: ' + repr(self.username) + ' ' +\
7609            '>'
7610
7611    def to_dict(self):
7612        return {
7613            'bind_interface': self.bind_interface,
7614            'database': self.database,
7615            'egress_filter': self.egress_filter,
7616            'healthy': self.healthy,
7617            'hostname': self.hostname,
7618            'id': self.id,
7619            'name': self.name,
7620            'password': self.password,
7621            'port': self.port,
7622            'port_override': self.port_override,
7623            'secret_store_id': self.secret_store_id,
7624            'tags': self.tags,
7625            'username': self.username,
7626        }
7627
7628    @classmethod
7629    def from_dict(cls, d):
7630        return cls(
7631            bind_interface=d.get('bind_interface'),
7632            database=d.get('database'),
7633            egress_filter=d.get('egress_filter'),
7634            healthy=d.get('healthy'),
7635            hostname=d.get('hostname'),
7636            id=d.get('id'),
7637            name=d.get('name'),
7638            password=d.get('password'),
7639            port=d.get('port'),
7640            port_override=d.get('port_override'),
7641            secret_store_id=d.get('secret_store_id'),
7642            tags=d.get('tags'),
7643            username=d.get('username'),
7644        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7543    def __init__(
7544        self,
7545        bind_interface=None,
7546        database=None,
7547        egress_filter=None,
7548        healthy=None,
7549        hostname=None,
7550        id=None,
7551        name=None,
7552        password=None,
7553        port=None,
7554        port_override=None,
7555        secret_store_id=None,
7556        tags=None,
7557        username=None,
7558    ):
7559        self.bind_interface = bind_interface if bind_interface is not None else ''
7560        '''
7561         Bind interface
7562        '''
7563        self.database = database if database is not None else ''
7564        self.egress_filter = egress_filter if egress_filter is not None else ''
7565        '''
7566         A filter applied to the routing logic to pin datasource to nodes.
7567        '''
7568        self.healthy = healthy if healthy is not None else False
7569        '''
7570         True if the datasource is reachable and the credentials are valid.
7571        '''
7572        self.hostname = hostname if hostname is not None else ''
7573        self.id = id if id is not None else ''
7574        '''
7575         Unique identifier of the Resource.
7576        '''
7577        self.name = name if name is not None else ''
7578        '''
7579         Unique human-readable name of the Resource.
7580        '''
7581        self.password = password if password is not None else ''
7582        self.port = port if port is not None else 0
7583        self.port_override = port_override if port_override is not None else 0
7584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7585        '''
7586         ID of the secret store containing credentials for this resource, if any.
7587        '''
7588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7589        '''
7590         Tags is a map of key, value pairs.
7591        '''
7592        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7611    def to_dict(self):
7612        return {
7613            'bind_interface': self.bind_interface,
7614            'database': self.database,
7615            'egress_filter': self.egress_filter,
7616            'healthy': self.healthy,
7617            'hostname': self.hostname,
7618            'id': self.id,
7619            'name': self.name,
7620            'password': self.password,
7621            'port': self.port,
7622            'port_override': self.port_override,
7623            'secret_store_id': self.secret_store_id,
7624            'tags': self.tags,
7625            'username': self.username,
7626        }
@classmethod
def from_dict(cls, d)
7628    @classmethod
7629    def from_dict(cls, d):
7630        return cls(
7631            bind_interface=d.get('bind_interface'),
7632            database=d.get('database'),
7633            egress_filter=d.get('egress_filter'),
7634            healthy=d.get('healthy'),
7635            hostname=d.get('hostname'),
7636            id=d.get('id'),
7637            name=d.get('name'),
7638            password=d.get('password'),
7639            port=d.get('port'),
7640            port_override=d.get('port_override'),
7641            secret_store_id=d.get('secret_store_id'),
7642            tags=d.get('tags'),
7643            username=d.get('username'),
7644        )
class MongoHost:
7647class MongoHost:
7648    '''
7649    MongoHost is currently unstable, and its API may change, or it may be removed,
7650    without a major version bump.
7651    '''
7652    __slots__ = [
7653        'auth_database',
7654        'bind_interface',
7655        'egress_filter',
7656        'healthy',
7657        'hostname',
7658        'id',
7659        'name',
7660        'password',
7661        'port',
7662        'port_override',
7663        'secret_store_id',
7664        'tags',
7665        'tls_required',
7666        'username',
7667    ]
7668
7669    def __init__(
7670        self,
7671        auth_database=None,
7672        bind_interface=None,
7673        egress_filter=None,
7674        healthy=None,
7675        hostname=None,
7676        id=None,
7677        name=None,
7678        password=None,
7679        port=None,
7680        port_override=None,
7681        secret_store_id=None,
7682        tags=None,
7683        tls_required=None,
7684        username=None,
7685    ):
7686        self.auth_database = auth_database if auth_database is not None else ''
7687        self.bind_interface = bind_interface if bind_interface is not None else ''
7688        '''
7689         Bind interface
7690        '''
7691        self.egress_filter = egress_filter if egress_filter is not None else ''
7692        '''
7693         A filter applied to the routing logic to pin datasource to nodes.
7694        '''
7695        self.healthy = healthy if healthy is not None else False
7696        '''
7697         True if the datasource is reachable and the credentials are valid.
7698        '''
7699        self.hostname = hostname if hostname is not None else ''
7700        self.id = id if id is not None else ''
7701        '''
7702         Unique identifier of the Resource.
7703        '''
7704        self.name = name if name is not None else ''
7705        '''
7706         Unique human-readable name of the Resource.
7707        '''
7708        self.password = password if password is not None else ''
7709        self.port = port if port is not None else 0
7710        self.port_override = port_override if port_override is not None else 0
7711        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7712        '''
7713         ID of the secret store containing credentials for this resource, if any.
7714        '''
7715        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7716        '''
7717         Tags is a map of key, value pairs.
7718        '''
7719        self.tls_required = tls_required if tls_required is not None else False
7720        self.username = username if username is not None else ''
7721
7722    def __repr__(self):
7723        return '<sdm.MongoHost ' + \
7724            'auth_database: ' + repr(self.auth_database) + ' ' +\
7725            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7726            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7727            'healthy: ' + repr(self.healthy) + ' ' +\
7728            'hostname: ' + repr(self.hostname) + ' ' +\
7729            'id: ' + repr(self.id) + ' ' +\
7730            'name: ' + repr(self.name) + ' ' +\
7731            'password: ' + repr(self.password) + ' ' +\
7732            'port: ' + repr(self.port) + ' ' +\
7733            'port_override: ' + repr(self.port_override) + ' ' +\
7734            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7735            'tags: ' + repr(self.tags) + ' ' +\
7736            'tls_required: ' + repr(self.tls_required) + ' ' +\
7737            'username: ' + repr(self.username) + ' ' +\
7738            '>'
7739
7740    def to_dict(self):
7741        return {
7742            'auth_database': self.auth_database,
7743            'bind_interface': self.bind_interface,
7744            'egress_filter': self.egress_filter,
7745            'healthy': self.healthy,
7746            'hostname': self.hostname,
7747            'id': self.id,
7748            'name': self.name,
7749            'password': self.password,
7750            'port': self.port,
7751            'port_override': self.port_override,
7752            'secret_store_id': self.secret_store_id,
7753            'tags': self.tags,
7754            'tls_required': self.tls_required,
7755            'username': self.username,
7756        }
7757
7758    @classmethod
7759    def from_dict(cls, d):
7760        return cls(
7761            auth_database=d.get('auth_database'),
7762            bind_interface=d.get('bind_interface'),
7763            egress_filter=d.get('egress_filter'),
7764            healthy=d.get('healthy'),
7765            hostname=d.get('hostname'),
7766            id=d.get('id'),
7767            name=d.get('name'),
7768            password=d.get('password'),
7769            port=d.get('port'),
7770            port_override=d.get('port_override'),
7771            secret_store_id=d.get('secret_store_id'),
7772            tags=d.get('tags'),
7773            tls_required=d.get('tls_required'),
7774            username=d.get('username'),
7775        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7669    def __init__(
7670        self,
7671        auth_database=None,
7672        bind_interface=None,
7673        egress_filter=None,
7674        healthy=None,
7675        hostname=None,
7676        id=None,
7677        name=None,
7678        password=None,
7679        port=None,
7680        port_override=None,
7681        secret_store_id=None,
7682        tags=None,
7683        tls_required=None,
7684        username=None,
7685    ):
7686        self.auth_database = auth_database if auth_database is not None else ''
7687        self.bind_interface = bind_interface if bind_interface is not None else ''
7688        '''
7689         Bind interface
7690        '''
7691        self.egress_filter = egress_filter if egress_filter is not None else ''
7692        '''
7693         A filter applied to the routing logic to pin datasource to nodes.
7694        '''
7695        self.healthy = healthy if healthy is not None else False
7696        '''
7697         True if the datasource is reachable and the credentials are valid.
7698        '''
7699        self.hostname = hostname if hostname is not None else ''
7700        self.id = id if id is not None else ''
7701        '''
7702         Unique identifier of the Resource.
7703        '''
7704        self.name = name if name is not None else ''
7705        '''
7706         Unique human-readable name of the Resource.
7707        '''
7708        self.password = password if password is not None else ''
7709        self.port = port if port is not None else 0
7710        self.port_override = port_override if port_override is not None else 0
7711        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7712        '''
7713         ID of the secret store containing credentials for this resource, if any.
7714        '''
7715        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7716        '''
7717         Tags is a map of key, value pairs.
7718        '''
7719        self.tls_required = tls_required if tls_required is not None else False
7720        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7740    def to_dict(self):
7741        return {
7742            'auth_database': self.auth_database,
7743            'bind_interface': self.bind_interface,
7744            'egress_filter': self.egress_filter,
7745            'healthy': self.healthy,
7746            'hostname': self.hostname,
7747            'id': self.id,
7748            'name': self.name,
7749            'password': self.password,
7750            'port': self.port,
7751            'port_override': self.port_override,
7752            'secret_store_id': self.secret_store_id,
7753            'tags': self.tags,
7754            'tls_required': self.tls_required,
7755            'username': self.username,
7756        }
@classmethod
def from_dict(cls, d)
7758    @classmethod
7759    def from_dict(cls, d):
7760        return cls(
7761            auth_database=d.get('auth_database'),
7762            bind_interface=d.get('bind_interface'),
7763            egress_filter=d.get('egress_filter'),
7764            healthy=d.get('healthy'),
7765            hostname=d.get('hostname'),
7766            id=d.get('id'),
7767            name=d.get('name'),
7768            password=d.get('password'),
7769            port=d.get('port'),
7770            port_override=d.get('port_override'),
7771            secret_store_id=d.get('secret_store_id'),
7772            tags=d.get('tags'),
7773            tls_required=d.get('tls_required'),
7774            username=d.get('username'),
7775        )
class MongoLegacyHost:
7778class MongoLegacyHost:
7779    __slots__ = [
7780        'auth_database',
7781        'bind_interface',
7782        'egress_filter',
7783        'healthy',
7784        'hostname',
7785        'id',
7786        'name',
7787        'password',
7788        'port',
7789        'port_override',
7790        'replica_set',
7791        'secret_store_id',
7792        'tags',
7793        'tls_required',
7794        'username',
7795    ]
7796
7797    def __init__(
7798        self,
7799        auth_database=None,
7800        bind_interface=None,
7801        egress_filter=None,
7802        healthy=None,
7803        hostname=None,
7804        id=None,
7805        name=None,
7806        password=None,
7807        port=None,
7808        port_override=None,
7809        replica_set=None,
7810        secret_store_id=None,
7811        tags=None,
7812        tls_required=None,
7813        username=None,
7814    ):
7815        self.auth_database = auth_database if auth_database is not None else ''
7816        self.bind_interface = bind_interface if bind_interface is not None else ''
7817        '''
7818         Bind interface
7819        '''
7820        self.egress_filter = egress_filter if egress_filter is not None else ''
7821        '''
7822         A filter applied to the routing logic to pin datasource to nodes.
7823        '''
7824        self.healthy = healthy if healthy is not None else False
7825        '''
7826         True if the datasource is reachable and the credentials are valid.
7827        '''
7828        self.hostname = hostname if hostname is not None else ''
7829        self.id = id if id is not None else ''
7830        '''
7831         Unique identifier of the Resource.
7832        '''
7833        self.name = name if name is not None else ''
7834        '''
7835         Unique human-readable name of the Resource.
7836        '''
7837        self.password = password if password is not None else ''
7838        self.port = port if port is not None else 0
7839        self.port_override = port_override if port_override is not None else 0
7840        self.replica_set = replica_set if replica_set is not None else ''
7841        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7842        '''
7843         ID of the secret store containing credentials for this resource, if any.
7844        '''
7845        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7846        '''
7847         Tags is a map of key, value pairs.
7848        '''
7849        self.tls_required = tls_required if tls_required is not None else False
7850        self.username = username if username is not None else ''
7851
7852    def __repr__(self):
7853        return '<sdm.MongoLegacyHost ' + \
7854            'auth_database: ' + repr(self.auth_database) + ' ' +\
7855            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7856            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7857            'healthy: ' + repr(self.healthy) + ' ' +\
7858            'hostname: ' + repr(self.hostname) + ' ' +\
7859            'id: ' + repr(self.id) + ' ' +\
7860            'name: ' + repr(self.name) + ' ' +\
7861            'password: ' + repr(self.password) + ' ' +\
7862            'port: ' + repr(self.port) + ' ' +\
7863            'port_override: ' + repr(self.port_override) + ' ' +\
7864            'replica_set: ' + repr(self.replica_set) + ' ' +\
7865            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7866            'tags: ' + repr(self.tags) + ' ' +\
7867            'tls_required: ' + repr(self.tls_required) + ' ' +\
7868            'username: ' + repr(self.username) + ' ' +\
7869            '>'
7870
7871    def to_dict(self):
7872        return {
7873            'auth_database': self.auth_database,
7874            'bind_interface': self.bind_interface,
7875            'egress_filter': self.egress_filter,
7876            'healthy': self.healthy,
7877            'hostname': self.hostname,
7878            'id': self.id,
7879            'name': self.name,
7880            'password': self.password,
7881            'port': self.port,
7882            'port_override': self.port_override,
7883            'replica_set': self.replica_set,
7884            'secret_store_id': self.secret_store_id,
7885            'tags': self.tags,
7886            'tls_required': self.tls_required,
7887            'username': self.username,
7888        }
7889
7890    @classmethod
7891    def from_dict(cls, d):
7892        return cls(
7893            auth_database=d.get('auth_database'),
7894            bind_interface=d.get('bind_interface'),
7895            egress_filter=d.get('egress_filter'),
7896            healthy=d.get('healthy'),
7897            hostname=d.get('hostname'),
7898            id=d.get('id'),
7899            name=d.get('name'),
7900            password=d.get('password'),
7901            port=d.get('port'),
7902            port_override=d.get('port_override'),
7903            replica_set=d.get('replica_set'),
7904            secret_store_id=d.get('secret_store_id'),
7905            tags=d.get('tags'),
7906            tls_required=d.get('tls_required'),
7907            username=d.get('username'),
7908        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7797    def __init__(
7798        self,
7799        auth_database=None,
7800        bind_interface=None,
7801        egress_filter=None,
7802        healthy=None,
7803        hostname=None,
7804        id=None,
7805        name=None,
7806        password=None,
7807        port=None,
7808        port_override=None,
7809        replica_set=None,
7810        secret_store_id=None,
7811        tags=None,
7812        tls_required=None,
7813        username=None,
7814    ):
7815        self.auth_database = auth_database if auth_database is not None else ''
7816        self.bind_interface = bind_interface if bind_interface is not None else ''
7817        '''
7818         Bind interface
7819        '''
7820        self.egress_filter = egress_filter if egress_filter is not None else ''
7821        '''
7822         A filter applied to the routing logic to pin datasource to nodes.
7823        '''
7824        self.healthy = healthy if healthy is not None else False
7825        '''
7826         True if the datasource is reachable and the credentials are valid.
7827        '''
7828        self.hostname = hostname if hostname is not None else ''
7829        self.id = id if id is not None else ''
7830        '''
7831         Unique identifier of the Resource.
7832        '''
7833        self.name = name if name is not None else ''
7834        '''
7835         Unique human-readable name of the Resource.
7836        '''
7837        self.password = password if password is not None else ''
7838        self.port = port if port is not None else 0
7839        self.port_override = port_override if port_override is not None else 0
7840        self.replica_set = replica_set if replica_set is not None else ''
7841        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7842        '''
7843         ID of the secret store containing credentials for this resource, if any.
7844        '''
7845        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7846        '''
7847         Tags is a map of key, value pairs.
7848        '''
7849        self.tls_required = tls_required if tls_required is not None else False
7850        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7871    def to_dict(self):
7872        return {
7873            'auth_database': self.auth_database,
7874            'bind_interface': self.bind_interface,
7875            'egress_filter': self.egress_filter,
7876            'healthy': self.healthy,
7877            'hostname': self.hostname,
7878            'id': self.id,
7879            'name': self.name,
7880            'password': self.password,
7881            'port': self.port,
7882            'port_override': self.port_override,
7883            'replica_set': self.replica_set,
7884            'secret_store_id': self.secret_store_id,
7885            'tags': self.tags,
7886            'tls_required': self.tls_required,
7887            'username': self.username,
7888        }
@classmethod
def from_dict(cls, d)
7890    @classmethod
7891    def from_dict(cls, d):
7892        return cls(
7893            auth_database=d.get('auth_database'),
7894            bind_interface=d.get('bind_interface'),
7895            egress_filter=d.get('egress_filter'),
7896            healthy=d.get('healthy'),
7897            hostname=d.get('hostname'),
7898            id=d.get('id'),
7899            name=d.get('name'),
7900            password=d.get('password'),
7901            port=d.get('port'),
7902            port_override=d.get('port_override'),
7903            replica_set=d.get('replica_set'),
7904            secret_store_id=d.get('secret_store_id'),
7905            tags=d.get('tags'),
7906            tls_required=d.get('tls_required'),
7907            username=d.get('username'),
7908        )
class MongoLegacyReplicaset:
7911class MongoLegacyReplicaset:
7912    __slots__ = [
7913        'auth_database',
7914        'bind_interface',
7915        'connect_to_replica',
7916        'egress_filter',
7917        'healthy',
7918        'hostname',
7919        'id',
7920        'name',
7921        'password',
7922        'port',
7923        'port_override',
7924        'replica_set',
7925        'secret_store_id',
7926        'tags',
7927        'tls_required',
7928        'username',
7929    ]
7930
7931    def __init__(
7932        self,
7933        auth_database=None,
7934        bind_interface=None,
7935        connect_to_replica=None,
7936        egress_filter=None,
7937        healthy=None,
7938        hostname=None,
7939        id=None,
7940        name=None,
7941        password=None,
7942        port=None,
7943        port_override=None,
7944        replica_set=None,
7945        secret_store_id=None,
7946        tags=None,
7947        tls_required=None,
7948        username=None,
7949    ):
7950        self.auth_database = auth_database if auth_database is not None else ''
7951        self.bind_interface = bind_interface if bind_interface is not None else ''
7952        '''
7953         Bind interface
7954        '''
7955        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7956        self.egress_filter = egress_filter if egress_filter is not None else ''
7957        '''
7958         A filter applied to the routing logic to pin datasource to nodes.
7959        '''
7960        self.healthy = healthy if healthy is not None else False
7961        '''
7962         True if the datasource is reachable and the credentials are valid.
7963        '''
7964        self.hostname = hostname if hostname is not None else ''
7965        self.id = id if id is not None else ''
7966        '''
7967         Unique identifier of the Resource.
7968        '''
7969        self.name = name if name is not None else ''
7970        '''
7971         Unique human-readable name of the Resource.
7972        '''
7973        self.password = password if password is not None else ''
7974        self.port = port if port is not None else 0
7975        self.port_override = port_override if port_override is not None else 0
7976        self.replica_set = replica_set if replica_set is not None else ''
7977        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7978        '''
7979         ID of the secret store containing credentials for this resource, if any.
7980        '''
7981        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7982        '''
7983         Tags is a map of key, value pairs.
7984        '''
7985        self.tls_required = tls_required if tls_required is not None else False
7986        self.username = username if username is not None else ''
7987
7988    def __repr__(self):
7989        return '<sdm.MongoLegacyReplicaset ' + \
7990            'auth_database: ' + repr(self.auth_database) + ' ' +\
7991            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7992            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7993            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7994            'healthy: ' + repr(self.healthy) + ' ' +\
7995            'hostname: ' + repr(self.hostname) + ' ' +\
7996            'id: ' + repr(self.id) + ' ' +\
7997            'name: ' + repr(self.name) + ' ' +\
7998            'password: ' + repr(self.password) + ' ' +\
7999            'port: ' + repr(self.port) + ' ' +\
8000            'port_override: ' + repr(self.port_override) + ' ' +\
8001            'replica_set: ' + repr(self.replica_set) + ' ' +\
8002            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8003            'tags: ' + repr(self.tags) + ' ' +\
8004            'tls_required: ' + repr(self.tls_required) + ' ' +\
8005            'username: ' + repr(self.username) + ' ' +\
8006            '>'
8007
8008    def to_dict(self):
8009        return {
8010            'auth_database': self.auth_database,
8011            'bind_interface': self.bind_interface,
8012            'connect_to_replica': self.connect_to_replica,
8013            'egress_filter': self.egress_filter,
8014            'healthy': self.healthy,
8015            'hostname': self.hostname,
8016            'id': self.id,
8017            'name': self.name,
8018            'password': self.password,
8019            'port': self.port,
8020            'port_override': self.port_override,
8021            'replica_set': self.replica_set,
8022            'secret_store_id': self.secret_store_id,
8023            'tags': self.tags,
8024            'tls_required': self.tls_required,
8025            'username': self.username,
8026        }
8027
8028    @classmethod
8029    def from_dict(cls, d):
8030        return cls(
8031            auth_database=d.get('auth_database'),
8032            bind_interface=d.get('bind_interface'),
8033            connect_to_replica=d.get('connect_to_replica'),
8034            egress_filter=d.get('egress_filter'),
8035            healthy=d.get('healthy'),
8036            hostname=d.get('hostname'),
8037            id=d.get('id'),
8038            name=d.get('name'),
8039            password=d.get('password'),
8040            port=d.get('port'),
8041            port_override=d.get('port_override'),
8042            replica_set=d.get('replica_set'),
8043            secret_store_id=d.get('secret_store_id'),
8044            tags=d.get('tags'),
8045            tls_required=d.get('tls_required'),
8046            username=d.get('username'),
8047        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7931    def __init__(
7932        self,
7933        auth_database=None,
7934        bind_interface=None,
7935        connect_to_replica=None,
7936        egress_filter=None,
7937        healthy=None,
7938        hostname=None,
7939        id=None,
7940        name=None,
7941        password=None,
7942        port=None,
7943        port_override=None,
7944        replica_set=None,
7945        secret_store_id=None,
7946        tags=None,
7947        tls_required=None,
7948        username=None,
7949    ):
7950        self.auth_database = auth_database if auth_database is not None else ''
7951        self.bind_interface = bind_interface if bind_interface is not None else ''
7952        '''
7953         Bind interface
7954        '''
7955        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7956        self.egress_filter = egress_filter if egress_filter is not None else ''
7957        '''
7958         A filter applied to the routing logic to pin datasource to nodes.
7959        '''
7960        self.healthy = healthy if healthy is not None else False
7961        '''
7962         True if the datasource is reachable and the credentials are valid.
7963        '''
7964        self.hostname = hostname if hostname is not None else ''
7965        self.id = id if id is not None else ''
7966        '''
7967         Unique identifier of the Resource.
7968        '''
7969        self.name = name if name is not None else ''
7970        '''
7971         Unique human-readable name of the Resource.
7972        '''
7973        self.password = password if password is not None else ''
7974        self.port = port if port is not None else 0
7975        self.port_override = port_override if port_override is not None else 0
7976        self.replica_set = replica_set if replica_set is not None else ''
7977        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7978        '''
7979         ID of the secret store containing credentials for this resource, if any.
7980        '''
7981        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7982        '''
7983         Tags is a map of key, value pairs.
7984        '''
7985        self.tls_required = tls_required if tls_required is not None else False
7986        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8008    def to_dict(self):
8009        return {
8010            'auth_database': self.auth_database,
8011            'bind_interface': self.bind_interface,
8012            'connect_to_replica': self.connect_to_replica,
8013            'egress_filter': self.egress_filter,
8014            'healthy': self.healthy,
8015            'hostname': self.hostname,
8016            'id': self.id,
8017            'name': self.name,
8018            'password': self.password,
8019            'port': self.port,
8020            'port_override': self.port_override,
8021            'replica_set': self.replica_set,
8022            'secret_store_id': self.secret_store_id,
8023            'tags': self.tags,
8024            'tls_required': self.tls_required,
8025            'username': self.username,
8026        }
@classmethod
def from_dict(cls, d)
8028    @classmethod
8029    def from_dict(cls, d):
8030        return cls(
8031            auth_database=d.get('auth_database'),
8032            bind_interface=d.get('bind_interface'),
8033            connect_to_replica=d.get('connect_to_replica'),
8034            egress_filter=d.get('egress_filter'),
8035            healthy=d.get('healthy'),
8036            hostname=d.get('hostname'),
8037            id=d.get('id'),
8038            name=d.get('name'),
8039            password=d.get('password'),
8040            port=d.get('port'),
8041            port_override=d.get('port_override'),
8042            replica_set=d.get('replica_set'),
8043            secret_store_id=d.get('secret_store_id'),
8044            tags=d.get('tags'),
8045            tls_required=d.get('tls_required'),
8046            username=d.get('username'),
8047        )
class MongoReplicaSet:
8050class MongoReplicaSet:
8051    '''
8052    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
8053    without a major version bump.
8054    '''
8055    __slots__ = [
8056        'auth_database',
8057        'bind_interface',
8058        'connect_to_replica',
8059        'egress_filter',
8060        'healthy',
8061        'hostname',
8062        'id',
8063        'name',
8064        'password',
8065        'port',
8066        'port_override',
8067        'replica_set',
8068        'secret_store_id',
8069        'tags',
8070        'tls_required',
8071        'username',
8072    ]
8073
8074    def __init__(
8075        self,
8076        auth_database=None,
8077        bind_interface=None,
8078        connect_to_replica=None,
8079        egress_filter=None,
8080        healthy=None,
8081        hostname=None,
8082        id=None,
8083        name=None,
8084        password=None,
8085        port=None,
8086        port_override=None,
8087        replica_set=None,
8088        secret_store_id=None,
8089        tags=None,
8090        tls_required=None,
8091        username=None,
8092    ):
8093        self.auth_database = auth_database if auth_database is not None else ''
8094        self.bind_interface = bind_interface if bind_interface is not None else ''
8095        '''
8096         Bind interface
8097        '''
8098        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8099        self.egress_filter = egress_filter if egress_filter is not None else ''
8100        '''
8101         A filter applied to the routing logic to pin datasource to nodes.
8102        '''
8103        self.healthy = healthy if healthy is not None else False
8104        '''
8105         True if the datasource is reachable and the credentials are valid.
8106        '''
8107        self.hostname = hostname if hostname is not None else ''
8108        self.id = id if id is not None else ''
8109        '''
8110         Unique identifier of the Resource.
8111        '''
8112        self.name = name if name is not None else ''
8113        '''
8114         Unique human-readable name of the Resource.
8115        '''
8116        self.password = password if password is not None else ''
8117        self.port = port if port is not None else 0
8118        self.port_override = port_override if port_override is not None else 0
8119        self.replica_set = replica_set if replica_set is not None else ''
8120        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8121        '''
8122         ID of the secret store containing credentials for this resource, if any.
8123        '''
8124        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8125        '''
8126         Tags is a map of key, value pairs.
8127        '''
8128        self.tls_required = tls_required if tls_required is not None else False
8129        self.username = username if username is not None else ''
8130
8131    def __repr__(self):
8132        return '<sdm.MongoReplicaSet ' + \
8133            'auth_database: ' + repr(self.auth_database) + ' ' +\
8134            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8135            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8136            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8137            'healthy: ' + repr(self.healthy) + ' ' +\
8138            'hostname: ' + repr(self.hostname) + ' ' +\
8139            'id: ' + repr(self.id) + ' ' +\
8140            'name: ' + repr(self.name) + ' ' +\
8141            'password: ' + repr(self.password) + ' ' +\
8142            'port: ' + repr(self.port) + ' ' +\
8143            'port_override: ' + repr(self.port_override) + ' ' +\
8144            'replica_set: ' + repr(self.replica_set) + ' ' +\
8145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8146            'tags: ' + repr(self.tags) + ' ' +\
8147            'tls_required: ' + repr(self.tls_required) + ' ' +\
8148            'username: ' + repr(self.username) + ' ' +\
8149            '>'
8150
8151    def to_dict(self):
8152        return {
8153            'auth_database': self.auth_database,
8154            'bind_interface': self.bind_interface,
8155            'connect_to_replica': self.connect_to_replica,
8156            'egress_filter': self.egress_filter,
8157            'healthy': self.healthy,
8158            'hostname': self.hostname,
8159            'id': self.id,
8160            'name': self.name,
8161            'password': self.password,
8162            'port': self.port,
8163            'port_override': self.port_override,
8164            'replica_set': self.replica_set,
8165            'secret_store_id': self.secret_store_id,
8166            'tags': self.tags,
8167            'tls_required': self.tls_required,
8168            'username': self.username,
8169        }
8170
8171    @classmethod
8172    def from_dict(cls, d):
8173        return cls(
8174            auth_database=d.get('auth_database'),
8175            bind_interface=d.get('bind_interface'),
8176            connect_to_replica=d.get('connect_to_replica'),
8177            egress_filter=d.get('egress_filter'),
8178            healthy=d.get('healthy'),
8179            hostname=d.get('hostname'),
8180            id=d.get('id'),
8181            name=d.get('name'),
8182            password=d.get('password'),
8183            port=d.get('port'),
8184            port_override=d.get('port_override'),
8185            replica_set=d.get('replica_set'),
8186            secret_store_id=d.get('secret_store_id'),
8187            tags=d.get('tags'),
8188            tls_required=d.get('tls_required'),
8189            username=d.get('username'),
8190        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8074    def __init__(
8075        self,
8076        auth_database=None,
8077        bind_interface=None,
8078        connect_to_replica=None,
8079        egress_filter=None,
8080        healthy=None,
8081        hostname=None,
8082        id=None,
8083        name=None,
8084        password=None,
8085        port=None,
8086        port_override=None,
8087        replica_set=None,
8088        secret_store_id=None,
8089        tags=None,
8090        tls_required=None,
8091        username=None,
8092    ):
8093        self.auth_database = auth_database if auth_database is not None else ''
8094        self.bind_interface = bind_interface if bind_interface is not None else ''
8095        '''
8096         Bind interface
8097        '''
8098        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8099        self.egress_filter = egress_filter if egress_filter is not None else ''
8100        '''
8101         A filter applied to the routing logic to pin datasource to nodes.
8102        '''
8103        self.healthy = healthy if healthy is not None else False
8104        '''
8105         True if the datasource is reachable and the credentials are valid.
8106        '''
8107        self.hostname = hostname if hostname is not None else ''
8108        self.id = id if id is not None else ''
8109        '''
8110         Unique identifier of the Resource.
8111        '''
8112        self.name = name if name is not None else ''
8113        '''
8114         Unique human-readable name of the Resource.
8115        '''
8116        self.password = password if password is not None else ''
8117        self.port = port if port is not None else 0
8118        self.port_override = port_override if port_override is not None else 0
8119        self.replica_set = replica_set if replica_set is not None else ''
8120        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8121        '''
8122         ID of the secret store containing credentials for this resource, if any.
8123        '''
8124        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8125        '''
8126         Tags is a map of key, value pairs.
8127        '''
8128        self.tls_required = tls_required if tls_required is not None else False
8129        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8151    def to_dict(self):
8152        return {
8153            'auth_database': self.auth_database,
8154            'bind_interface': self.bind_interface,
8155            'connect_to_replica': self.connect_to_replica,
8156            'egress_filter': self.egress_filter,
8157            'healthy': self.healthy,
8158            'hostname': self.hostname,
8159            'id': self.id,
8160            'name': self.name,
8161            'password': self.password,
8162            'port': self.port,
8163            'port_override': self.port_override,
8164            'replica_set': self.replica_set,
8165            'secret_store_id': self.secret_store_id,
8166            'tags': self.tags,
8167            'tls_required': self.tls_required,
8168            'username': self.username,
8169        }
@classmethod
def from_dict(cls, d)
8171    @classmethod
8172    def from_dict(cls, d):
8173        return cls(
8174            auth_database=d.get('auth_database'),
8175            bind_interface=d.get('bind_interface'),
8176            connect_to_replica=d.get('connect_to_replica'),
8177            egress_filter=d.get('egress_filter'),
8178            healthy=d.get('healthy'),
8179            hostname=d.get('hostname'),
8180            id=d.get('id'),
8181            name=d.get('name'),
8182            password=d.get('password'),
8183            port=d.get('port'),
8184            port_override=d.get('port_override'),
8185            replica_set=d.get('replica_set'),
8186            secret_store_id=d.get('secret_store_id'),
8187            tags=d.get('tags'),
8188            tls_required=d.get('tls_required'),
8189            username=d.get('username'),
8190        )
class MongoShardedCluster:
8193class MongoShardedCluster:
8194    '''
8195    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
8196    without a major version bump.
8197    '''
8198    __slots__ = [
8199        'auth_database',
8200        'bind_interface',
8201        'egress_filter',
8202        'healthy',
8203        'hostname',
8204        'id',
8205        'name',
8206        'password',
8207        'port_override',
8208        'secret_store_id',
8209        'tags',
8210        'tls_required',
8211        'username',
8212    ]
8213
8214    def __init__(
8215        self,
8216        auth_database=None,
8217        bind_interface=None,
8218        egress_filter=None,
8219        healthy=None,
8220        hostname=None,
8221        id=None,
8222        name=None,
8223        password=None,
8224        port_override=None,
8225        secret_store_id=None,
8226        tags=None,
8227        tls_required=None,
8228        username=None,
8229    ):
8230        self.auth_database = auth_database if auth_database is not None else ''
8231        self.bind_interface = bind_interface if bind_interface is not None else ''
8232        '''
8233         Bind interface
8234        '''
8235        self.egress_filter = egress_filter if egress_filter is not None else ''
8236        '''
8237         A filter applied to the routing logic to pin datasource to nodes.
8238        '''
8239        self.healthy = healthy if healthy is not None else False
8240        '''
8241         True if the datasource is reachable and the credentials are valid.
8242        '''
8243        self.hostname = hostname if hostname is not None else ''
8244        self.id = id if id is not None else ''
8245        '''
8246         Unique identifier of the Resource.
8247        '''
8248        self.name = name if name is not None else ''
8249        '''
8250         Unique human-readable name of the Resource.
8251        '''
8252        self.password = password if password is not None else ''
8253        self.port_override = port_override if port_override is not None else 0
8254        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8255        '''
8256         ID of the secret store containing credentials for this resource, if any.
8257        '''
8258        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8259        '''
8260         Tags is a map of key, value pairs.
8261        '''
8262        self.tls_required = tls_required if tls_required is not None else False
8263        self.username = username if username is not None else ''
8264
8265    def __repr__(self):
8266        return '<sdm.MongoShardedCluster ' + \
8267            'auth_database: ' + repr(self.auth_database) + ' ' +\
8268            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8269            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8270            'healthy: ' + repr(self.healthy) + ' ' +\
8271            'hostname: ' + repr(self.hostname) + ' ' +\
8272            'id: ' + repr(self.id) + ' ' +\
8273            'name: ' + repr(self.name) + ' ' +\
8274            'password: ' + repr(self.password) + ' ' +\
8275            'port_override: ' + repr(self.port_override) + ' ' +\
8276            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8277            'tags: ' + repr(self.tags) + ' ' +\
8278            'tls_required: ' + repr(self.tls_required) + ' ' +\
8279            'username: ' + repr(self.username) + ' ' +\
8280            '>'
8281
8282    def to_dict(self):
8283        return {
8284            'auth_database': self.auth_database,
8285            'bind_interface': self.bind_interface,
8286            'egress_filter': self.egress_filter,
8287            'healthy': self.healthy,
8288            'hostname': self.hostname,
8289            'id': self.id,
8290            'name': self.name,
8291            'password': self.password,
8292            'port_override': self.port_override,
8293            'secret_store_id': self.secret_store_id,
8294            'tags': self.tags,
8295            'tls_required': self.tls_required,
8296            'username': self.username,
8297        }
8298
8299    @classmethod
8300    def from_dict(cls, d):
8301        return cls(
8302            auth_database=d.get('auth_database'),
8303            bind_interface=d.get('bind_interface'),
8304            egress_filter=d.get('egress_filter'),
8305            healthy=d.get('healthy'),
8306            hostname=d.get('hostname'),
8307            id=d.get('id'),
8308            name=d.get('name'),
8309            password=d.get('password'),
8310            port_override=d.get('port_override'),
8311            secret_store_id=d.get('secret_store_id'),
8312            tags=d.get('tags'),
8313            tls_required=d.get('tls_required'),
8314            username=d.get('username'),
8315        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8214    def __init__(
8215        self,
8216        auth_database=None,
8217        bind_interface=None,
8218        egress_filter=None,
8219        healthy=None,
8220        hostname=None,
8221        id=None,
8222        name=None,
8223        password=None,
8224        port_override=None,
8225        secret_store_id=None,
8226        tags=None,
8227        tls_required=None,
8228        username=None,
8229    ):
8230        self.auth_database = auth_database if auth_database is not None else ''
8231        self.bind_interface = bind_interface if bind_interface is not None else ''
8232        '''
8233         Bind interface
8234        '''
8235        self.egress_filter = egress_filter if egress_filter is not None else ''
8236        '''
8237         A filter applied to the routing logic to pin datasource to nodes.
8238        '''
8239        self.healthy = healthy if healthy is not None else False
8240        '''
8241         True if the datasource is reachable and the credentials are valid.
8242        '''
8243        self.hostname = hostname if hostname is not None else ''
8244        self.id = id if id is not None else ''
8245        '''
8246         Unique identifier of the Resource.
8247        '''
8248        self.name = name if name is not None else ''
8249        '''
8250         Unique human-readable name of the Resource.
8251        '''
8252        self.password = password if password is not None else ''
8253        self.port_override = port_override if port_override is not None else 0
8254        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8255        '''
8256         ID of the secret store containing credentials for this resource, if any.
8257        '''
8258        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8259        '''
8260         Tags is a map of key, value pairs.
8261        '''
8262        self.tls_required = tls_required if tls_required is not None else False
8263        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8282    def to_dict(self):
8283        return {
8284            'auth_database': self.auth_database,
8285            'bind_interface': self.bind_interface,
8286            'egress_filter': self.egress_filter,
8287            'healthy': self.healthy,
8288            'hostname': self.hostname,
8289            'id': self.id,
8290            'name': self.name,
8291            'password': self.password,
8292            'port_override': self.port_override,
8293            'secret_store_id': self.secret_store_id,
8294            'tags': self.tags,
8295            'tls_required': self.tls_required,
8296            'username': self.username,
8297        }
@classmethod
def from_dict(cls, d)
8299    @classmethod
8300    def from_dict(cls, d):
8301        return cls(
8302            auth_database=d.get('auth_database'),
8303            bind_interface=d.get('bind_interface'),
8304            egress_filter=d.get('egress_filter'),
8305            healthy=d.get('healthy'),
8306            hostname=d.get('hostname'),
8307            id=d.get('id'),
8308            name=d.get('name'),
8309            password=d.get('password'),
8310            port_override=d.get('port_override'),
8311            secret_store_id=d.get('secret_store_id'),
8312            tags=d.get('tags'),
8313            tls_required=d.get('tls_required'),
8314            username=d.get('username'),
8315        )
class Mysql:
8318class Mysql:
8319    __slots__ = [
8320        'bind_interface',
8321        'database',
8322        'egress_filter',
8323        'healthy',
8324        'hostname',
8325        'id',
8326        'name',
8327        'password',
8328        'port',
8329        'port_override',
8330        'secret_store_id',
8331        'tags',
8332        'username',
8333    ]
8334
8335    def __init__(
8336        self,
8337        bind_interface=None,
8338        database=None,
8339        egress_filter=None,
8340        healthy=None,
8341        hostname=None,
8342        id=None,
8343        name=None,
8344        password=None,
8345        port=None,
8346        port_override=None,
8347        secret_store_id=None,
8348        tags=None,
8349        username=None,
8350    ):
8351        self.bind_interface = bind_interface if bind_interface is not None else ''
8352        '''
8353         Bind interface
8354        '''
8355        self.database = database if database is not None else ''
8356        self.egress_filter = egress_filter if egress_filter is not None else ''
8357        '''
8358         A filter applied to the routing logic to pin datasource to nodes.
8359        '''
8360        self.healthy = healthy if healthy is not None else False
8361        '''
8362         True if the datasource is reachable and the credentials are valid.
8363        '''
8364        self.hostname = hostname if hostname is not None else ''
8365        self.id = id if id is not None else ''
8366        '''
8367         Unique identifier of the Resource.
8368        '''
8369        self.name = name if name is not None else ''
8370        '''
8371         Unique human-readable name of the Resource.
8372        '''
8373        self.password = password if password is not None else ''
8374        self.port = port if port is not None else 0
8375        self.port_override = port_override if port_override is not None else 0
8376        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8377        '''
8378         ID of the secret store containing credentials for this resource, if any.
8379        '''
8380        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8381        '''
8382         Tags is a map of key, value pairs.
8383        '''
8384        self.username = username if username is not None else ''
8385
8386    def __repr__(self):
8387        return '<sdm.Mysql ' + \
8388            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8389            'database: ' + repr(self.database) + ' ' +\
8390            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8391            'healthy: ' + repr(self.healthy) + ' ' +\
8392            'hostname: ' + repr(self.hostname) + ' ' +\
8393            'id: ' + repr(self.id) + ' ' +\
8394            'name: ' + repr(self.name) + ' ' +\
8395            'password: ' + repr(self.password) + ' ' +\
8396            'port: ' + repr(self.port) + ' ' +\
8397            'port_override: ' + repr(self.port_override) + ' ' +\
8398            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8399            'tags: ' + repr(self.tags) + ' ' +\
8400            'username: ' + repr(self.username) + ' ' +\
8401            '>'
8402
8403    def to_dict(self):
8404        return {
8405            'bind_interface': self.bind_interface,
8406            'database': self.database,
8407            'egress_filter': self.egress_filter,
8408            'healthy': self.healthy,
8409            'hostname': self.hostname,
8410            'id': self.id,
8411            'name': self.name,
8412            'password': self.password,
8413            'port': self.port,
8414            'port_override': self.port_override,
8415            'secret_store_id': self.secret_store_id,
8416            'tags': self.tags,
8417            'username': self.username,
8418        }
8419
8420    @classmethod
8421    def from_dict(cls, d):
8422        return cls(
8423            bind_interface=d.get('bind_interface'),
8424            database=d.get('database'),
8425            egress_filter=d.get('egress_filter'),
8426            healthy=d.get('healthy'),
8427            hostname=d.get('hostname'),
8428            id=d.get('id'),
8429            name=d.get('name'),
8430            password=d.get('password'),
8431            port=d.get('port'),
8432            port_override=d.get('port_override'),
8433            secret_store_id=d.get('secret_store_id'),
8434            tags=d.get('tags'),
8435            username=d.get('username'),
8436        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8335    def __init__(
8336        self,
8337        bind_interface=None,
8338        database=None,
8339        egress_filter=None,
8340        healthy=None,
8341        hostname=None,
8342        id=None,
8343        name=None,
8344        password=None,
8345        port=None,
8346        port_override=None,
8347        secret_store_id=None,
8348        tags=None,
8349        username=None,
8350    ):
8351        self.bind_interface = bind_interface if bind_interface is not None else ''
8352        '''
8353         Bind interface
8354        '''
8355        self.database = database if database is not None else ''
8356        self.egress_filter = egress_filter if egress_filter is not None else ''
8357        '''
8358         A filter applied to the routing logic to pin datasource to nodes.
8359        '''
8360        self.healthy = healthy if healthy is not None else False
8361        '''
8362         True if the datasource is reachable and the credentials are valid.
8363        '''
8364        self.hostname = hostname if hostname is not None else ''
8365        self.id = id if id is not None else ''
8366        '''
8367         Unique identifier of the Resource.
8368        '''
8369        self.name = name if name is not None else ''
8370        '''
8371         Unique human-readable name of the Resource.
8372        '''
8373        self.password = password if password is not None else ''
8374        self.port = port if port is not None else 0
8375        self.port_override = port_override if port_override is not None else 0
8376        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8377        '''
8378         ID of the secret store containing credentials for this resource, if any.
8379        '''
8380        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8381        '''
8382         Tags is a map of key, value pairs.
8383        '''
8384        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8403    def to_dict(self):
8404        return {
8405            'bind_interface': self.bind_interface,
8406            'database': self.database,
8407            'egress_filter': self.egress_filter,
8408            'healthy': self.healthy,
8409            'hostname': self.hostname,
8410            'id': self.id,
8411            'name': self.name,
8412            'password': self.password,
8413            'port': self.port,
8414            'port_override': self.port_override,
8415            'secret_store_id': self.secret_store_id,
8416            'tags': self.tags,
8417            'username': self.username,
8418        }
@classmethod
def from_dict(cls, d)
8420    @classmethod
8421    def from_dict(cls, d):
8422        return cls(
8423            bind_interface=d.get('bind_interface'),
8424            database=d.get('database'),
8425            egress_filter=d.get('egress_filter'),
8426            healthy=d.get('healthy'),
8427            hostname=d.get('hostname'),
8428            id=d.get('id'),
8429            name=d.get('name'),
8430            password=d.get('password'),
8431            port=d.get('port'),
8432            port_override=d.get('port_override'),
8433            secret_store_id=d.get('secret_store_id'),
8434            tags=d.get('tags'),
8435            username=d.get('username'),
8436        )
class Neptune:
8439class Neptune:
8440    __slots__ = [
8441        'bind_interface',
8442        'egress_filter',
8443        'endpoint',
8444        'healthy',
8445        'id',
8446        'name',
8447        'port',
8448        'port_override',
8449        'secret_store_id',
8450        'tags',
8451    ]
8452
8453    def __init__(
8454        self,
8455        bind_interface=None,
8456        egress_filter=None,
8457        endpoint=None,
8458        healthy=None,
8459        id=None,
8460        name=None,
8461        port=None,
8462        port_override=None,
8463        secret_store_id=None,
8464        tags=None,
8465    ):
8466        self.bind_interface = bind_interface if bind_interface is not None else ''
8467        '''
8468         Bind interface
8469        '''
8470        self.egress_filter = egress_filter if egress_filter is not None else ''
8471        '''
8472         A filter applied to the routing logic to pin datasource to nodes.
8473        '''
8474        self.endpoint = endpoint if endpoint is not None else ''
8475        self.healthy = healthy if healthy is not None else False
8476        '''
8477         True if the datasource is reachable and the credentials are valid.
8478        '''
8479        self.id = id if id is not None else ''
8480        '''
8481         Unique identifier of the Resource.
8482        '''
8483        self.name = name if name is not None else ''
8484        '''
8485         Unique human-readable name of the Resource.
8486        '''
8487        self.port = port if port is not None else 0
8488        self.port_override = port_override if port_override is not None else 0
8489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8490        '''
8491         ID of the secret store containing credentials for this resource, if any.
8492        '''
8493        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8494        '''
8495         Tags is a map of key, value pairs.
8496        '''
8497
8498    def __repr__(self):
8499        return '<sdm.Neptune ' + \
8500            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8501            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8502            'endpoint: ' + repr(self.endpoint) + ' ' +\
8503            'healthy: ' + repr(self.healthy) + ' ' +\
8504            'id: ' + repr(self.id) + ' ' +\
8505            'name: ' + repr(self.name) + ' ' +\
8506            'port: ' + repr(self.port) + ' ' +\
8507            'port_override: ' + repr(self.port_override) + ' ' +\
8508            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8509            'tags: ' + repr(self.tags) + ' ' +\
8510            '>'
8511
8512    def to_dict(self):
8513        return {
8514            'bind_interface': self.bind_interface,
8515            'egress_filter': self.egress_filter,
8516            'endpoint': self.endpoint,
8517            'healthy': self.healthy,
8518            'id': self.id,
8519            'name': self.name,
8520            'port': self.port,
8521            'port_override': self.port_override,
8522            'secret_store_id': self.secret_store_id,
8523            'tags': self.tags,
8524        }
8525
8526    @classmethod
8527    def from_dict(cls, d):
8528        return cls(
8529            bind_interface=d.get('bind_interface'),
8530            egress_filter=d.get('egress_filter'),
8531            endpoint=d.get('endpoint'),
8532            healthy=d.get('healthy'),
8533            id=d.get('id'),
8534            name=d.get('name'),
8535            port=d.get('port'),
8536            port_override=d.get('port_override'),
8537            secret_store_id=d.get('secret_store_id'),
8538            tags=d.get('tags'),
8539        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8453    def __init__(
8454        self,
8455        bind_interface=None,
8456        egress_filter=None,
8457        endpoint=None,
8458        healthy=None,
8459        id=None,
8460        name=None,
8461        port=None,
8462        port_override=None,
8463        secret_store_id=None,
8464        tags=None,
8465    ):
8466        self.bind_interface = bind_interface if bind_interface is not None else ''
8467        '''
8468         Bind interface
8469        '''
8470        self.egress_filter = egress_filter if egress_filter is not None else ''
8471        '''
8472         A filter applied to the routing logic to pin datasource to nodes.
8473        '''
8474        self.endpoint = endpoint if endpoint is not None else ''
8475        self.healthy = healthy if healthy is not None else False
8476        '''
8477         True if the datasource is reachable and the credentials are valid.
8478        '''
8479        self.id = id if id is not None else ''
8480        '''
8481         Unique identifier of the Resource.
8482        '''
8483        self.name = name if name is not None else ''
8484        '''
8485         Unique human-readable name of the Resource.
8486        '''
8487        self.port = port if port is not None else 0
8488        self.port_override = port_override if port_override is not None else 0
8489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8490        '''
8491         ID of the secret store containing credentials for this resource, if any.
8492        '''
8493        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8494        '''
8495         Tags is a map of key, value pairs.
8496        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8512    def to_dict(self):
8513        return {
8514            'bind_interface': self.bind_interface,
8515            'egress_filter': self.egress_filter,
8516            'endpoint': self.endpoint,
8517            'healthy': self.healthy,
8518            'id': self.id,
8519            'name': self.name,
8520            'port': self.port,
8521            'port_override': self.port_override,
8522            'secret_store_id': self.secret_store_id,
8523            'tags': self.tags,
8524        }
@classmethod
def from_dict(cls, d)
8526    @classmethod
8527    def from_dict(cls, d):
8528        return cls(
8529            bind_interface=d.get('bind_interface'),
8530            egress_filter=d.get('egress_filter'),
8531            endpoint=d.get('endpoint'),
8532            healthy=d.get('healthy'),
8533            id=d.get('id'),
8534            name=d.get('name'),
8535            port=d.get('port'),
8536            port_override=d.get('port_override'),
8537            secret_store_id=d.get('secret_store_id'),
8538            tags=d.get('tags'),
8539        )
class NeptuneIAM:
8542class NeptuneIAM:
8543    __slots__ = [
8544        'access_key',
8545        'bind_interface',
8546        'egress_filter',
8547        'endpoint',
8548        'healthy',
8549        'id',
8550        'name',
8551        'port',
8552        'port_override',
8553        'region',
8554        'role_arn',
8555        'role_external_id',
8556        'secret_access_key',
8557        'secret_store_id',
8558        'tags',
8559    ]
8560
8561    def __init__(
8562        self,
8563        access_key=None,
8564        bind_interface=None,
8565        egress_filter=None,
8566        endpoint=None,
8567        healthy=None,
8568        id=None,
8569        name=None,
8570        port=None,
8571        port_override=None,
8572        region=None,
8573        role_arn=None,
8574        role_external_id=None,
8575        secret_access_key=None,
8576        secret_store_id=None,
8577        tags=None,
8578    ):
8579        self.access_key = access_key if access_key is not None else ''
8580        self.bind_interface = bind_interface if bind_interface is not None else ''
8581        '''
8582         Bind interface
8583        '''
8584        self.egress_filter = egress_filter if egress_filter is not None else ''
8585        '''
8586         A filter applied to the routing logic to pin datasource to nodes.
8587        '''
8588        self.endpoint = endpoint if endpoint is not None else ''
8589        self.healthy = healthy if healthy is not None else False
8590        '''
8591         True if the datasource is reachable and the credentials are valid.
8592        '''
8593        self.id = id if id is not None else ''
8594        '''
8595         Unique identifier of the Resource.
8596        '''
8597        self.name = name if name is not None else ''
8598        '''
8599         Unique human-readable name of the Resource.
8600        '''
8601        self.port = port if port is not None else 0
8602        self.port_override = port_override if port_override is not None else 0
8603        self.region = region if region is not None else ''
8604        self.role_arn = role_arn if role_arn is not None else ''
8605        self.role_external_id = role_external_id if role_external_id is not None else ''
8606        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8607        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8608        '''
8609         ID of the secret store containing credentials for this resource, if any.
8610        '''
8611        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8612        '''
8613         Tags is a map of key, value pairs.
8614        '''
8615
8616    def __repr__(self):
8617        return '<sdm.NeptuneIAM ' + \
8618            'access_key: ' + repr(self.access_key) + ' ' +\
8619            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8621            'endpoint: ' + repr(self.endpoint) + ' ' +\
8622            'healthy: ' + repr(self.healthy) + ' ' +\
8623            'id: ' + repr(self.id) + ' ' +\
8624            'name: ' + repr(self.name) + ' ' +\
8625            'port: ' + repr(self.port) + ' ' +\
8626            'port_override: ' + repr(self.port_override) + ' ' +\
8627            'region: ' + repr(self.region) + ' ' +\
8628            'role_arn: ' + repr(self.role_arn) + ' ' +\
8629            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8630            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8631            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8632            'tags: ' + repr(self.tags) + ' ' +\
8633            '>'
8634
8635    def to_dict(self):
8636        return {
8637            'access_key': self.access_key,
8638            'bind_interface': self.bind_interface,
8639            'egress_filter': self.egress_filter,
8640            'endpoint': self.endpoint,
8641            'healthy': self.healthy,
8642            'id': self.id,
8643            'name': self.name,
8644            'port': self.port,
8645            'port_override': self.port_override,
8646            'region': self.region,
8647            'role_arn': self.role_arn,
8648            'role_external_id': self.role_external_id,
8649            'secret_access_key': self.secret_access_key,
8650            'secret_store_id': self.secret_store_id,
8651            'tags': self.tags,
8652        }
8653
8654    @classmethod
8655    def from_dict(cls, d):
8656        return cls(
8657            access_key=d.get('access_key'),
8658            bind_interface=d.get('bind_interface'),
8659            egress_filter=d.get('egress_filter'),
8660            endpoint=d.get('endpoint'),
8661            healthy=d.get('healthy'),
8662            id=d.get('id'),
8663            name=d.get('name'),
8664            port=d.get('port'),
8665            port_override=d.get('port_override'),
8666            region=d.get('region'),
8667            role_arn=d.get('role_arn'),
8668            role_external_id=d.get('role_external_id'),
8669            secret_access_key=d.get('secret_access_key'),
8670            secret_store_id=d.get('secret_store_id'),
8671            tags=d.get('tags'),
8672        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8561    def __init__(
8562        self,
8563        access_key=None,
8564        bind_interface=None,
8565        egress_filter=None,
8566        endpoint=None,
8567        healthy=None,
8568        id=None,
8569        name=None,
8570        port=None,
8571        port_override=None,
8572        region=None,
8573        role_arn=None,
8574        role_external_id=None,
8575        secret_access_key=None,
8576        secret_store_id=None,
8577        tags=None,
8578    ):
8579        self.access_key = access_key if access_key is not None else ''
8580        self.bind_interface = bind_interface if bind_interface is not None else ''
8581        '''
8582         Bind interface
8583        '''
8584        self.egress_filter = egress_filter if egress_filter is not None else ''
8585        '''
8586         A filter applied to the routing logic to pin datasource to nodes.
8587        '''
8588        self.endpoint = endpoint if endpoint is not None else ''
8589        self.healthy = healthy if healthy is not None else False
8590        '''
8591         True if the datasource is reachable and the credentials are valid.
8592        '''
8593        self.id = id if id is not None else ''
8594        '''
8595         Unique identifier of the Resource.
8596        '''
8597        self.name = name if name is not None else ''
8598        '''
8599         Unique human-readable name of the Resource.
8600        '''
8601        self.port = port if port is not None else 0
8602        self.port_override = port_override if port_override is not None else 0
8603        self.region = region if region is not None else ''
8604        self.role_arn = role_arn if role_arn is not None else ''
8605        self.role_external_id = role_external_id if role_external_id is not None else ''
8606        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8607        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8608        '''
8609         ID of the secret store containing credentials for this resource, if any.
8610        '''
8611        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8612        '''
8613         Tags is a map of key, value pairs.
8614        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8635    def to_dict(self):
8636        return {
8637            'access_key': self.access_key,
8638            'bind_interface': self.bind_interface,
8639            'egress_filter': self.egress_filter,
8640            'endpoint': self.endpoint,
8641            'healthy': self.healthy,
8642            'id': self.id,
8643            'name': self.name,
8644            'port': self.port,
8645            'port_override': self.port_override,
8646            'region': self.region,
8647            'role_arn': self.role_arn,
8648            'role_external_id': self.role_external_id,
8649            'secret_access_key': self.secret_access_key,
8650            'secret_store_id': self.secret_store_id,
8651            'tags': self.tags,
8652        }
@classmethod
def from_dict(cls, d)
8654    @classmethod
8655    def from_dict(cls, d):
8656        return cls(
8657            access_key=d.get('access_key'),
8658            bind_interface=d.get('bind_interface'),
8659            egress_filter=d.get('egress_filter'),
8660            endpoint=d.get('endpoint'),
8661            healthy=d.get('healthy'),
8662            id=d.get('id'),
8663            name=d.get('name'),
8664            port=d.get('port'),
8665            port_override=d.get('port_override'),
8666            region=d.get('region'),
8667            role_arn=d.get('role_arn'),
8668            role_external_id=d.get('role_external_id'),
8669            secret_access_key=d.get('secret_access_key'),
8670            secret_store_id=d.get('secret_store_id'),
8671            tags=d.get('tags'),
8672        )
class NodeCreateResponse:
8675class NodeCreateResponse:
8676    '''
8677         NodeCreateResponse reports how the Nodes were created in the system.
8678    '''
8679    __slots__ = [
8680        'meta',
8681        'node',
8682        'rate_limit',
8683        'token',
8684    ]
8685
8686    def __init__(
8687        self,
8688        meta=None,
8689        node=None,
8690        rate_limit=None,
8691        token=None,
8692    ):
8693        self.meta = meta if meta is not None else None
8694        '''
8695         Reserved for future use.
8696        '''
8697        self.node = node if node is not None else None
8698        '''
8699         The created Node.
8700        '''
8701        self.rate_limit = rate_limit if rate_limit is not None else None
8702        '''
8703         Rate limit information.
8704        '''
8705        self.token = token if token is not None else ''
8706        '''
8707         The auth token generated for the Node. The Node will use this token to
8708         authenticate with the strongDM API.
8709        '''
8710
8711    def __repr__(self):
8712        return '<sdm.NodeCreateResponse ' + \
8713            'meta: ' + repr(self.meta) + ' ' +\
8714            'node: ' + repr(self.node) + ' ' +\
8715            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8716            'token: ' + repr(self.token) + ' ' +\
8717            '>'
8718
8719    def to_dict(self):
8720        return {
8721            'meta': self.meta,
8722            'node': self.node,
8723            'rate_limit': self.rate_limit,
8724            'token': self.token,
8725        }
8726
8727    @classmethod
8728    def from_dict(cls, d):
8729        return cls(
8730            meta=d.get('meta'),
8731            node=d.get('node'),
8732            rate_limit=d.get('rate_limit'),
8733            token=d.get('token'),
8734        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8686    def __init__(
8687        self,
8688        meta=None,
8689        node=None,
8690        rate_limit=None,
8691        token=None,
8692    ):
8693        self.meta = meta if meta is not None else None
8694        '''
8695         Reserved for future use.
8696        '''
8697        self.node = node if node is not None else None
8698        '''
8699         The created Node.
8700        '''
8701        self.rate_limit = rate_limit if rate_limit is not None else None
8702        '''
8703         Rate limit information.
8704        '''
8705        self.token = token if token is not None else ''
8706        '''
8707         The auth token generated for the Node. The Node will use this token to
8708         authenticate with the strongDM API.
8709        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8719    def to_dict(self):
8720        return {
8721            'meta': self.meta,
8722            'node': self.node,
8723            'rate_limit': self.rate_limit,
8724            'token': self.token,
8725        }
@classmethod
def from_dict(cls, d)
8727    @classmethod
8728    def from_dict(cls, d):
8729        return cls(
8730            meta=d.get('meta'),
8731            node=d.get('node'),
8732            rate_limit=d.get('rate_limit'),
8733            token=d.get('token'),
8734        )
class NodeDeleteResponse:
8737class NodeDeleteResponse:
8738    '''
8739         NodeDeleteResponse returns information about a Node that was deleted.
8740    '''
8741    __slots__ = [
8742        'meta',
8743        'rate_limit',
8744    ]
8745
8746    def __init__(
8747        self,
8748        meta=None,
8749        rate_limit=None,
8750    ):
8751        self.meta = meta if meta is not None else None
8752        '''
8753         Reserved for future use.
8754        '''
8755        self.rate_limit = rate_limit if rate_limit is not None else None
8756        '''
8757         Rate limit information.
8758        '''
8759
8760    def __repr__(self):
8761        return '<sdm.NodeDeleteResponse ' + \
8762            'meta: ' + repr(self.meta) + ' ' +\
8763            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8764            '>'
8765
8766    def to_dict(self):
8767        return {
8768            'meta': self.meta,
8769            'rate_limit': self.rate_limit,
8770        }
8771
8772    @classmethod
8773    def from_dict(cls, d):
8774        return cls(
8775            meta=d.get('meta'),
8776            rate_limit=d.get('rate_limit'),
8777        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8746    def __init__(
8747        self,
8748        meta=None,
8749        rate_limit=None,
8750    ):
8751        self.meta = meta if meta is not None else None
8752        '''
8753         Reserved for future use.
8754        '''
8755        self.rate_limit = rate_limit if rate_limit is not None else None
8756        '''
8757         Rate limit information.
8758        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8766    def to_dict(self):
8767        return {
8768            'meta': self.meta,
8769            'rate_limit': self.rate_limit,
8770        }
@classmethod
def from_dict(cls, d)
8772    @classmethod
8773    def from_dict(cls, d):
8774        return cls(
8775            meta=d.get('meta'),
8776            rate_limit=d.get('rate_limit'),
8777        )
class NodeGetResponse:
8780class NodeGetResponse:
8781    '''
8782         NodeGetResponse returns a requested Node.
8783    '''
8784    __slots__ = [
8785        'meta',
8786        'node',
8787        'rate_limit',
8788    ]
8789
8790    def __init__(
8791        self,
8792        meta=None,
8793        node=None,
8794        rate_limit=None,
8795    ):
8796        self.meta = meta if meta is not None else None
8797        '''
8798         Reserved for future use.
8799        '''
8800        self.node = node if node is not None else None
8801        '''
8802         The requested Node.
8803        '''
8804        self.rate_limit = rate_limit if rate_limit is not None else None
8805        '''
8806         Rate limit information.
8807        '''
8808
8809    def __repr__(self):
8810        return '<sdm.NodeGetResponse ' + \
8811            'meta: ' + repr(self.meta) + ' ' +\
8812            'node: ' + repr(self.node) + ' ' +\
8813            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8814            '>'
8815
8816    def to_dict(self):
8817        return {
8818            'meta': self.meta,
8819            'node': self.node,
8820            'rate_limit': self.rate_limit,
8821        }
8822
8823    @classmethod
8824    def from_dict(cls, d):
8825        return cls(
8826            meta=d.get('meta'),
8827            node=d.get('node'),
8828            rate_limit=d.get('rate_limit'),
8829        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8790    def __init__(
8791        self,
8792        meta=None,
8793        node=None,
8794        rate_limit=None,
8795    ):
8796        self.meta = meta if meta is not None else None
8797        '''
8798         Reserved for future use.
8799        '''
8800        self.node = node if node is not None else None
8801        '''
8802         The requested Node.
8803        '''
8804        self.rate_limit = rate_limit if rate_limit is not None else None
8805        '''
8806         Rate limit information.
8807        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8816    def to_dict(self):
8817        return {
8818            'meta': self.meta,
8819            'node': self.node,
8820            'rate_limit': self.rate_limit,
8821        }
@classmethod
def from_dict(cls, d)
8823    @classmethod
8824    def from_dict(cls, d):
8825        return cls(
8826            meta=d.get('meta'),
8827            node=d.get('node'),
8828            rate_limit=d.get('rate_limit'),
8829        )
class NodeUpdateResponse:
8832class NodeUpdateResponse:
8833    '''
8834         NodeUpdateResponse returns the fields of a Node after it has been updated by
8835     a NodeUpdateRequest.
8836    '''
8837    __slots__ = [
8838        'meta',
8839        'node',
8840        'rate_limit',
8841    ]
8842
8843    def __init__(
8844        self,
8845        meta=None,
8846        node=None,
8847        rate_limit=None,
8848    ):
8849        self.meta = meta if meta is not None else None
8850        '''
8851         Reserved for future use.
8852        '''
8853        self.node = node if node is not None else None
8854        '''
8855         The updated Node.
8856        '''
8857        self.rate_limit = rate_limit if rate_limit is not None else None
8858        '''
8859         Rate limit information.
8860        '''
8861
8862    def __repr__(self):
8863        return '<sdm.NodeUpdateResponse ' + \
8864            'meta: ' + repr(self.meta) + ' ' +\
8865            'node: ' + repr(self.node) + ' ' +\
8866            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8867            '>'
8868
8869    def to_dict(self):
8870        return {
8871            'meta': self.meta,
8872            'node': self.node,
8873            'rate_limit': self.rate_limit,
8874        }
8875
8876    @classmethod
8877    def from_dict(cls, d):
8878        return cls(
8879            meta=d.get('meta'),
8880            node=d.get('node'),
8881            rate_limit=d.get('rate_limit'),
8882        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8843    def __init__(
8844        self,
8845        meta=None,
8846        node=None,
8847        rate_limit=None,
8848    ):
8849        self.meta = meta if meta is not None else None
8850        '''
8851         Reserved for future use.
8852        '''
8853        self.node = node if node is not None else None
8854        '''
8855         The updated Node.
8856        '''
8857        self.rate_limit = rate_limit if rate_limit is not None else None
8858        '''
8859         Rate limit information.
8860        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8869    def to_dict(self):
8870        return {
8871            'meta': self.meta,
8872            'node': self.node,
8873            'rate_limit': self.rate_limit,
8874        }
@classmethod
def from_dict(cls, d)
8876    @classmethod
8877    def from_dict(cls, d):
8878        return cls(
8879            meta=d.get('meta'),
8880            node=d.get('node'),
8881            rate_limit=d.get('rate_limit'),
8882        )
class Oracle:
8885class Oracle:
8886    __slots__ = [
8887        'bind_interface',
8888        'database',
8889        'egress_filter',
8890        'healthy',
8891        'hostname',
8892        'id',
8893        'name',
8894        'password',
8895        'port',
8896        'port_override',
8897        'secret_store_id',
8898        'tags',
8899        'tls_required',
8900        'username',
8901    ]
8902
8903    def __init__(
8904        self,
8905        bind_interface=None,
8906        database=None,
8907        egress_filter=None,
8908        healthy=None,
8909        hostname=None,
8910        id=None,
8911        name=None,
8912        password=None,
8913        port=None,
8914        port_override=None,
8915        secret_store_id=None,
8916        tags=None,
8917        tls_required=None,
8918        username=None,
8919    ):
8920        self.bind_interface = bind_interface if bind_interface is not None else ''
8921        '''
8922         Bind interface
8923        '''
8924        self.database = database if database is not None else ''
8925        self.egress_filter = egress_filter if egress_filter is not None else ''
8926        '''
8927         A filter applied to the routing logic to pin datasource to nodes.
8928        '''
8929        self.healthy = healthy if healthy is not None else False
8930        '''
8931         True if the datasource is reachable and the credentials are valid.
8932        '''
8933        self.hostname = hostname if hostname is not None else ''
8934        self.id = id if id is not None else ''
8935        '''
8936         Unique identifier of the Resource.
8937        '''
8938        self.name = name if name is not None else ''
8939        '''
8940         Unique human-readable name of the Resource.
8941        '''
8942        self.password = password if password is not None else ''
8943        self.port = port if port is not None else 0
8944        self.port_override = port_override if port_override is not None else 0
8945        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8946        '''
8947         ID of the secret store containing credentials for this resource, if any.
8948        '''
8949        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8950        '''
8951         Tags is a map of key, value pairs.
8952        '''
8953        self.tls_required = tls_required if tls_required is not None else False
8954        self.username = username if username is not None else ''
8955
8956    def __repr__(self):
8957        return '<sdm.Oracle ' + \
8958            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8959            'database: ' + repr(self.database) + ' ' +\
8960            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8961            'healthy: ' + repr(self.healthy) + ' ' +\
8962            'hostname: ' + repr(self.hostname) + ' ' +\
8963            'id: ' + repr(self.id) + ' ' +\
8964            'name: ' + repr(self.name) + ' ' +\
8965            'password: ' + repr(self.password) + ' ' +\
8966            'port: ' + repr(self.port) + ' ' +\
8967            'port_override: ' + repr(self.port_override) + ' ' +\
8968            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8969            'tags: ' + repr(self.tags) + ' ' +\
8970            'tls_required: ' + repr(self.tls_required) + ' ' +\
8971            'username: ' + repr(self.username) + ' ' +\
8972            '>'
8973
8974    def to_dict(self):
8975        return {
8976            'bind_interface': self.bind_interface,
8977            'database': self.database,
8978            'egress_filter': self.egress_filter,
8979            'healthy': self.healthy,
8980            'hostname': self.hostname,
8981            'id': self.id,
8982            'name': self.name,
8983            'password': self.password,
8984            'port': self.port,
8985            'port_override': self.port_override,
8986            'secret_store_id': self.secret_store_id,
8987            'tags': self.tags,
8988            'tls_required': self.tls_required,
8989            'username': self.username,
8990        }
8991
8992    @classmethod
8993    def from_dict(cls, d):
8994        return cls(
8995            bind_interface=d.get('bind_interface'),
8996            database=d.get('database'),
8997            egress_filter=d.get('egress_filter'),
8998            healthy=d.get('healthy'),
8999            hostname=d.get('hostname'),
9000            id=d.get('id'),
9001            name=d.get('name'),
9002            password=d.get('password'),
9003            port=d.get('port'),
9004            port_override=d.get('port_override'),
9005            secret_store_id=d.get('secret_store_id'),
9006            tags=d.get('tags'),
9007            tls_required=d.get('tls_required'),
9008            username=d.get('username'),
9009        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8903    def __init__(
8904        self,
8905        bind_interface=None,
8906        database=None,
8907        egress_filter=None,
8908        healthy=None,
8909        hostname=None,
8910        id=None,
8911        name=None,
8912        password=None,
8913        port=None,
8914        port_override=None,
8915        secret_store_id=None,
8916        tags=None,
8917        tls_required=None,
8918        username=None,
8919    ):
8920        self.bind_interface = bind_interface if bind_interface is not None else ''
8921        '''
8922         Bind interface
8923        '''
8924        self.database = database if database is not None else ''
8925        self.egress_filter = egress_filter if egress_filter is not None else ''
8926        '''
8927         A filter applied to the routing logic to pin datasource to nodes.
8928        '''
8929        self.healthy = healthy if healthy is not None else False
8930        '''
8931         True if the datasource is reachable and the credentials are valid.
8932        '''
8933        self.hostname = hostname if hostname is not None else ''
8934        self.id = id if id is not None else ''
8935        '''
8936         Unique identifier of the Resource.
8937        '''
8938        self.name = name if name is not None else ''
8939        '''
8940         Unique human-readable name of the Resource.
8941        '''
8942        self.password = password if password is not None else ''
8943        self.port = port if port is not None else 0
8944        self.port_override = port_override if port_override is not None else 0
8945        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8946        '''
8947         ID of the secret store containing credentials for this resource, if any.
8948        '''
8949        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8950        '''
8951         Tags is a map of key, value pairs.
8952        '''
8953        self.tls_required = tls_required if tls_required is not None else False
8954        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8974    def to_dict(self):
8975        return {
8976            'bind_interface': self.bind_interface,
8977            'database': self.database,
8978            'egress_filter': self.egress_filter,
8979            'healthy': self.healthy,
8980            'hostname': self.hostname,
8981            'id': self.id,
8982            'name': self.name,
8983            'password': self.password,
8984            'port': self.port,
8985            'port_override': self.port_override,
8986            'secret_store_id': self.secret_store_id,
8987            'tags': self.tags,
8988            'tls_required': self.tls_required,
8989            'username': self.username,
8990        }
@classmethod
def from_dict(cls, d)
8992    @classmethod
8993    def from_dict(cls, d):
8994        return cls(
8995            bind_interface=d.get('bind_interface'),
8996            database=d.get('database'),
8997            egress_filter=d.get('egress_filter'),
8998            healthy=d.get('healthy'),
8999            hostname=d.get('hostname'),
9000            id=d.get('id'),
9001            name=d.get('name'),
9002            password=d.get('password'),
9003            port=d.get('port'),
9004            port_override=d.get('port_override'),
9005            secret_store_id=d.get('secret_store_id'),
9006            tags=d.get('tags'),
9007            tls_required=d.get('tls_required'),
9008            username=d.get('username'),
9009        )
class Postgres:
9012class Postgres:
9013    __slots__ = [
9014        'bind_interface',
9015        'database',
9016        'egress_filter',
9017        'healthy',
9018        'hostname',
9019        'id',
9020        'name',
9021        'override_database',
9022        'password',
9023        'port',
9024        'port_override',
9025        'secret_store_id',
9026        'tags',
9027        'username',
9028    ]
9029
9030    def __init__(
9031        self,
9032        bind_interface=None,
9033        database=None,
9034        egress_filter=None,
9035        healthy=None,
9036        hostname=None,
9037        id=None,
9038        name=None,
9039        override_database=None,
9040        password=None,
9041        port=None,
9042        port_override=None,
9043        secret_store_id=None,
9044        tags=None,
9045        username=None,
9046    ):
9047        self.bind_interface = bind_interface if bind_interface is not None else ''
9048        '''
9049         Bind interface
9050        '''
9051        self.database = database if database is not None else ''
9052        self.egress_filter = egress_filter if egress_filter is not None else ''
9053        '''
9054         A filter applied to the routing logic to pin datasource to nodes.
9055        '''
9056        self.healthy = healthy if healthy is not None else False
9057        '''
9058         True if the datasource is reachable and the credentials are valid.
9059        '''
9060        self.hostname = hostname if hostname is not None else ''
9061        self.id = id if id is not None else ''
9062        '''
9063         Unique identifier of the Resource.
9064        '''
9065        self.name = name if name is not None else ''
9066        '''
9067         Unique human-readable name of the Resource.
9068        '''
9069        self.override_database = override_database if override_database is not None else False
9070        self.password = password if password is not None else ''
9071        self.port = port if port is not None else 0
9072        self.port_override = port_override if port_override is not None else 0
9073        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9074        '''
9075         ID of the secret store containing credentials for this resource, if any.
9076        '''
9077        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9078        '''
9079         Tags is a map of key, value pairs.
9080        '''
9081        self.username = username if username is not None else ''
9082
9083    def __repr__(self):
9084        return '<sdm.Postgres ' + \
9085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9086            'database: ' + repr(self.database) + ' ' +\
9087            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9088            'healthy: ' + repr(self.healthy) + ' ' +\
9089            'hostname: ' + repr(self.hostname) + ' ' +\
9090            'id: ' + repr(self.id) + ' ' +\
9091            'name: ' + repr(self.name) + ' ' +\
9092            'override_database: ' + repr(self.override_database) + ' ' +\
9093            'password: ' + repr(self.password) + ' ' +\
9094            'port: ' + repr(self.port) + ' ' +\
9095            'port_override: ' + repr(self.port_override) + ' ' +\
9096            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9097            'tags: ' + repr(self.tags) + ' ' +\
9098            'username: ' + repr(self.username) + ' ' +\
9099            '>'
9100
9101    def to_dict(self):
9102        return {
9103            'bind_interface': self.bind_interface,
9104            'database': self.database,
9105            'egress_filter': self.egress_filter,
9106            'healthy': self.healthy,
9107            'hostname': self.hostname,
9108            'id': self.id,
9109            'name': self.name,
9110            'override_database': self.override_database,
9111            'password': self.password,
9112            'port': self.port,
9113            'port_override': self.port_override,
9114            'secret_store_id': self.secret_store_id,
9115            'tags': self.tags,
9116            'username': self.username,
9117        }
9118
9119    @classmethod
9120    def from_dict(cls, d):
9121        return cls(
9122            bind_interface=d.get('bind_interface'),
9123            database=d.get('database'),
9124            egress_filter=d.get('egress_filter'),
9125            healthy=d.get('healthy'),
9126            hostname=d.get('hostname'),
9127            id=d.get('id'),
9128            name=d.get('name'),
9129            override_database=d.get('override_database'),
9130            password=d.get('password'),
9131            port=d.get('port'),
9132            port_override=d.get('port_override'),
9133            secret_store_id=d.get('secret_store_id'),
9134            tags=d.get('tags'),
9135            username=d.get('username'),
9136        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9030    def __init__(
9031        self,
9032        bind_interface=None,
9033        database=None,
9034        egress_filter=None,
9035        healthy=None,
9036        hostname=None,
9037        id=None,
9038        name=None,
9039        override_database=None,
9040        password=None,
9041        port=None,
9042        port_override=None,
9043        secret_store_id=None,
9044        tags=None,
9045        username=None,
9046    ):
9047        self.bind_interface = bind_interface if bind_interface is not None else ''
9048        '''
9049         Bind interface
9050        '''
9051        self.database = database if database is not None else ''
9052        self.egress_filter = egress_filter if egress_filter is not None else ''
9053        '''
9054         A filter applied to the routing logic to pin datasource to nodes.
9055        '''
9056        self.healthy = healthy if healthy is not None else False
9057        '''
9058         True if the datasource is reachable and the credentials are valid.
9059        '''
9060        self.hostname = hostname if hostname is not None else ''
9061        self.id = id if id is not None else ''
9062        '''
9063         Unique identifier of the Resource.
9064        '''
9065        self.name = name if name is not None else ''
9066        '''
9067         Unique human-readable name of the Resource.
9068        '''
9069        self.override_database = override_database if override_database is not None else False
9070        self.password = password if password is not None else ''
9071        self.port = port if port is not None else 0
9072        self.port_override = port_override if port_override is not None else 0
9073        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9074        '''
9075         ID of the secret store containing credentials for this resource, if any.
9076        '''
9077        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9078        '''
9079         Tags is a map of key, value pairs.
9080        '''
9081        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9101    def to_dict(self):
9102        return {
9103            'bind_interface': self.bind_interface,
9104            'database': self.database,
9105            'egress_filter': self.egress_filter,
9106            'healthy': self.healthy,
9107            'hostname': self.hostname,
9108            'id': self.id,
9109            'name': self.name,
9110            'override_database': self.override_database,
9111            'password': self.password,
9112            'port': self.port,
9113            'port_override': self.port_override,
9114            'secret_store_id': self.secret_store_id,
9115            'tags': self.tags,
9116            'username': self.username,
9117        }
@classmethod
def from_dict(cls, d)
9119    @classmethod
9120    def from_dict(cls, d):
9121        return cls(
9122            bind_interface=d.get('bind_interface'),
9123            database=d.get('database'),
9124            egress_filter=d.get('egress_filter'),
9125            healthy=d.get('healthy'),
9126            hostname=d.get('hostname'),
9127            id=d.get('id'),
9128            name=d.get('name'),
9129            override_database=d.get('override_database'),
9130            password=d.get('password'),
9131            port=d.get('port'),
9132            port_override=d.get('port_override'),
9133            secret_store_id=d.get('secret_store_id'),
9134            tags=d.get('tags'),
9135            username=d.get('username'),
9136        )
class Presto:
9139class Presto:
9140    __slots__ = [
9141        'bind_interface',
9142        'database',
9143        'egress_filter',
9144        'healthy',
9145        'hostname',
9146        'id',
9147        'name',
9148        'password',
9149        'port',
9150        'port_override',
9151        'secret_store_id',
9152        'tags',
9153        'tls_required',
9154        'username',
9155    ]
9156
9157    def __init__(
9158        self,
9159        bind_interface=None,
9160        database=None,
9161        egress_filter=None,
9162        healthy=None,
9163        hostname=None,
9164        id=None,
9165        name=None,
9166        password=None,
9167        port=None,
9168        port_override=None,
9169        secret_store_id=None,
9170        tags=None,
9171        tls_required=None,
9172        username=None,
9173    ):
9174        self.bind_interface = bind_interface if bind_interface is not None else ''
9175        '''
9176         Bind interface
9177        '''
9178        self.database = database if database is not None else ''
9179        self.egress_filter = egress_filter if egress_filter is not None else ''
9180        '''
9181         A filter applied to the routing logic to pin datasource to nodes.
9182        '''
9183        self.healthy = healthy if healthy is not None else False
9184        '''
9185         True if the datasource is reachable and the credentials are valid.
9186        '''
9187        self.hostname = hostname if hostname is not None else ''
9188        self.id = id if id is not None else ''
9189        '''
9190         Unique identifier of the Resource.
9191        '''
9192        self.name = name if name is not None else ''
9193        '''
9194         Unique human-readable name of the Resource.
9195        '''
9196        self.password = password if password is not None else ''
9197        self.port = port if port is not None else 0
9198        self.port_override = port_override if port_override is not None else 0
9199        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9200        '''
9201         ID of the secret store containing credentials for this resource, if any.
9202        '''
9203        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9204        '''
9205         Tags is a map of key, value pairs.
9206        '''
9207        self.tls_required = tls_required if tls_required is not None else False
9208        self.username = username if username is not None else ''
9209
9210    def __repr__(self):
9211        return '<sdm.Presto ' + \
9212            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9213            'database: ' + repr(self.database) + ' ' +\
9214            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9215            'healthy: ' + repr(self.healthy) + ' ' +\
9216            'hostname: ' + repr(self.hostname) + ' ' +\
9217            'id: ' + repr(self.id) + ' ' +\
9218            'name: ' + repr(self.name) + ' ' +\
9219            'password: ' + repr(self.password) + ' ' +\
9220            'port: ' + repr(self.port) + ' ' +\
9221            'port_override: ' + repr(self.port_override) + ' ' +\
9222            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9223            'tags: ' + repr(self.tags) + ' ' +\
9224            'tls_required: ' + repr(self.tls_required) + ' ' +\
9225            'username: ' + repr(self.username) + ' ' +\
9226            '>'
9227
9228    def to_dict(self):
9229        return {
9230            'bind_interface': self.bind_interface,
9231            'database': self.database,
9232            'egress_filter': self.egress_filter,
9233            'healthy': self.healthy,
9234            'hostname': self.hostname,
9235            'id': self.id,
9236            'name': self.name,
9237            'password': self.password,
9238            'port': self.port,
9239            'port_override': self.port_override,
9240            'secret_store_id': self.secret_store_id,
9241            'tags': self.tags,
9242            'tls_required': self.tls_required,
9243            'username': self.username,
9244        }
9245
9246    @classmethod
9247    def from_dict(cls, d):
9248        return cls(
9249            bind_interface=d.get('bind_interface'),
9250            database=d.get('database'),
9251            egress_filter=d.get('egress_filter'),
9252            healthy=d.get('healthy'),
9253            hostname=d.get('hostname'),
9254            id=d.get('id'),
9255            name=d.get('name'),
9256            password=d.get('password'),
9257            port=d.get('port'),
9258            port_override=d.get('port_override'),
9259            secret_store_id=d.get('secret_store_id'),
9260            tags=d.get('tags'),
9261            tls_required=d.get('tls_required'),
9262            username=d.get('username'),
9263        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9157    def __init__(
9158        self,
9159        bind_interface=None,
9160        database=None,
9161        egress_filter=None,
9162        healthy=None,
9163        hostname=None,
9164        id=None,
9165        name=None,
9166        password=None,
9167        port=None,
9168        port_override=None,
9169        secret_store_id=None,
9170        tags=None,
9171        tls_required=None,
9172        username=None,
9173    ):
9174        self.bind_interface = bind_interface if bind_interface is not None else ''
9175        '''
9176         Bind interface
9177        '''
9178        self.database = database if database is not None else ''
9179        self.egress_filter = egress_filter if egress_filter is not None else ''
9180        '''
9181         A filter applied to the routing logic to pin datasource to nodes.
9182        '''
9183        self.healthy = healthy if healthy is not None else False
9184        '''
9185         True if the datasource is reachable and the credentials are valid.
9186        '''
9187        self.hostname = hostname if hostname is not None else ''
9188        self.id = id if id is not None else ''
9189        '''
9190         Unique identifier of the Resource.
9191        '''
9192        self.name = name if name is not None else ''
9193        '''
9194         Unique human-readable name of the Resource.
9195        '''
9196        self.password = password if password is not None else ''
9197        self.port = port if port is not None else 0
9198        self.port_override = port_override if port_override is not None else 0
9199        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9200        '''
9201         ID of the secret store containing credentials for this resource, if any.
9202        '''
9203        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9204        '''
9205         Tags is a map of key, value pairs.
9206        '''
9207        self.tls_required = tls_required if tls_required is not None else False
9208        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9228    def to_dict(self):
9229        return {
9230            'bind_interface': self.bind_interface,
9231            'database': self.database,
9232            'egress_filter': self.egress_filter,
9233            'healthy': self.healthy,
9234            'hostname': self.hostname,
9235            'id': self.id,
9236            'name': self.name,
9237            'password': self.password,
9238            'port': self.port,
9239            'port_override': self.port_override,
9240            'secret_store_id': self.secret_store_id,
9241            'tags': self.tags,
9242            'tls_required': self.tls_required,
9243            'username': self.username,
9244        }
@classmethod
def from_dict(cls, d)
9246    @classmethod
9247    def from_dict(cls, d):
9248        return cls(
9249            bind_interface=d.get('bind_interface'),
9250            database=d.get('database'),
9251            egress_filter=d.get('egress_filter'),
9252            healthy=d.get('healthy'),
9253            hostname=d.get('hostname'),
9254            id=d.get('id'),
9255            name=d.get('name'),
9256            password=d.get('password'),
9257            port=d.get('port'),
9258            port_override=d.get('port_override'),
9259            secret_store_id=d.get('secret_store_id'),
9260            tags=d.get('tags'),
9261            tls_required=d.get('tls_required'),
9262            username=d.get('username'),
9263        )
class RDP:
9266class RDP:
9267    __slots__ = [
9268        'bind_interface',
9269        'downgrade_nla_connections',
9270        'egress_filter',
9271        'healthy',
9272        'hostname',
9273        'id',
9274        'name',
9275        'password',
9276        'port',
9277        'port_override',
9278        'secret_store_id',
9279        'tags',
9280        'username',
9281    ]
9282
9283    def __init__(
9284        self,
9285        bind_interface=None,
9286        downgrade_nla_connections=None,
9287        egress_filter=None,
9288        healthy=None,
9289        hostname=None,
9290        id=None,
9291        name=None,
9292        password=None,
9293        port=None,
9294        port_override=None,
9295        secret_store_id=None,
9296        tags=None,
9297        username=None,
9298    ):
9299        self.bind_interface = bind_interface if bind_interface is not None else ''
9300        '''
9301         Bind interface
9302        '''
9303        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9304        self.egress_filter = egress_filter if egress_filter is not None else ''
9305        '''
9306         A filter applied to the routing logic to pin datasource to nodes.
9307        '''
9308        self.healthy = healthy if healthy is not None else False
9309        '''
9310         True if the datasource is reachable and the credentials are valid.
9311        '''
9312        self.hostname = hostname if hostname is not None else ''
9313        self.id = id if id is not None else ''
9314        '''
9315         Unique identifier of the Resource.
9316        '''
9317        self.name = name if name is not None else ''
9318        '''
9319         Unique human-readable name of the Resource.
9320        '''
9321        self.password = password if password is not None else ''
9322        self.port = port if port is not None else 0
9323        self.port_override = port_override if port_override is not None else 0
9324        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9325        '''
9326         ID of the secret store containing credentials for this resource, if any.
9327        '''
9328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9329        '''
9330         Tags is a map of key, value pairs.
9331        '''
9332        self.username = username if username is not None else ''
9333
9334    def __repr__(self):
9335        return '<sdm.RDP ' + \
9336            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9337            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9338            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9339            'healthy: ' + repr(self.healthy) + ' ' +\
9340            'hostname: ' + repr(self.hostname) + ' ' +\
9341            'id: ' + repr(self.id) + ' ' +\
9342            'name: ' + repr(self.name) + ' ' +\
9343            'password: ' + repr(self.password) + ' ' +\
9344            'port: ' + repr(self.port) + ' ' +\
9345            'port_override: ' + repr(self.port_override) + ' ' +\
9346            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9347            'tags: ' + repr(self.tags) + ' ' +\
9348            'username: ' + repr(self.username) + ' ' +\
9349            '>'
9350
9351    def to_dict(self):
9352        return {
9353            'bind_interface': self.bind_interface,
9354            'downgrade_nla_connections': self.downgrade_nla_connections,
9355            'egress_filter': self.egress_filter,
9356            'healthy': self.healthy,
9357            'hostname': self.hostname,
9358            'id': self.id,
9359            'name': self.name,
9360            'password': self.password,
9361            'port': self.port,
9362            'port_override': self.port_override,
9363            'secret_store_id': self.secret_store_id,
9364            'tags': self.tags,
9365            'username': self.username,
9366        }
9367
9368    @classmethod
9369    def from_dict(cls, d):
9370        return cls(
9371            bind_interface=d.get('bind_interface'),
9372            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9373            egress_filter=d.get('egress_filter'),
9374            healthy=d.get('healthy'),
9375            hostname=d.get('hostname'),
9376            id=d.get('id'),
9377            name=d.get('name'),
9378            password=d.get('password'),
9379            port=d.get('port'),
9380            port_override=d.get('port_override'),
9381            secret_store_id=d.get('secret_store_id'),
9382            tags=d.get('tags'),
9383            username=d.get('username'),
9384        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9283    def __init__(
9284        self,
9285        bind_interface=None,
9286        downgrade_nla_connections=None,
9287        egress_filter=None,
9288        healthy=None,
9289        hostname=None,
9290        id=None,
9291        name=None,
9292        password=None,
9293        port=None,
9294        port_override=None,
9295        secret_store_id=None,
9296        tags=None,
9297        username=None,
9298    ):
9299        self.bind_interface = bind_interface if bind_interface is not None else ''
9300        '''
9301         Bind interface
9302        '''
9303        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9304        self.egress_filter = egress_filter if egress_filter is not None else ''
9305        '''
9306         A filter applied to the routing logic to pin datasource to nodes.
9307        '''
9308        self.healthy = healthy if healthy is not None else False
9309        '''
9310         True if the datasource is reachable and the credentials are valid.
9311        '''
9312        self.hostname = hostname if hostname is not None else ''
9313        self.id = id if id is not None else ''
9314        '''
9315         Unique identifier of the Resource.
9316        '''
9317        self.name = name if name is not None else ''
9318        '''
9319         Unique human-readable name of the Resource.
9320        '''
9321        self.password = password if password is not None else ''
9322        self.port = port if port is not None else 0
9323        self.port_override = port_override if port_override is not None else 0
9324        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9325        '''
9326         ID of the secret store containing credentials for this resource, if any.
9327        '''
9328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9329        '''
9330         Tags is a map of key, value pairs.
9331        '''
9332        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9351    def to_dict(self):
9352        return {
9353            'bind_interface': self.bind_interface,
9354            'downgrade_nla_connections': self.downgrade_nla_connections,
9355            'egress_filter': self.egress_filter,
9356            'healthy': self.healthy,
9357            'hostname': self.hostname,
9358            'id': self.id,
9359            'name': self.name,
9360            'password': self.password,
9361            'port': self.port,
9362            'port_override': self.port_override,
9363            'secret_store_id': self.secret_store_id,
9364            'tags': self.tags,
9365            'username': self.username,
9366        }
@classmethod
def from_dict(cls, d)
9368    @classmethod
9369    def from_dict(cls, d):
9370        return cls(
9371            bind_interface=d.get('bind_interface'),
9372            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9373            egress_filter=d.get('egress_filter'),
9374            healthy=d.get('healthy'),
9375            hostname=d.get('hostname'),
9376            id=d.get('id'),
9377            name=d.get('name'),
9378            password=d.get('password'),
9379            port=d.get('port'),
9380            port_override=d.get('port_override'),
9381            secret_store_id=d.get('secret_store_id'),
9382            tags=d.get('tags'),
9383            username=d.get('username'),
9384        )
class RabbitMQAMQP091:
9387class RabbitMQAMQP091:
9388    __slots__ = [
9389        'bind_interface',
9390        'egress_filter',
9391        'healthy',
9392        'hostname',
9393        'id',
9394        'name',
9395        'password',
9396        'port',
9397        'port_override',
9398        'secret_store_id',
9399        'tags',
9400        'tls_required',
9401        'username',
9402    ]
9403
9404    def __init__(
9405        self,
9406        bind_interface=None,
9407        egress_filter=None,
9408        healthy=None,
9409        hostname=None,
9410        id=None,
9411        name=None,
9412        password=None,
9413        port=None,
9414        port_override=None,
9415        secret_store_id=None,
9416        tags=None,
9417        tls_required=None,
9418        username=None,
9419    ):
9420        self.bind_interface = bind_interface if bind_interface is not None else ''
9421        '''
9422         Bind interface
9423        '''
9424        self.egress_filter = egress_filter if egress_filter is not None else ''
9425        '''
9426         A filter applied to the routing logic to pin datasource to nodes.
9427        '''
9428        self.healthy = healthy if healthy is not None else False
9429        '''
9430         True if the datasource is reachable and the credentials are valid.
9431        '''
9432        self.hostname = hostname if hostname is not None else ''
9433        self.id = id if id is not None else ''
9434        '''
9435         Unique identifier of the Resource.
9436        '''
9437        self.name = name if name is not None else ''
9438        '''
9439         Unique human-readable name of the Resource.
9440        '''
9441        self.password = password if password is not None else ''
9442        self.port = port if port is not None else 0
9443        self.port_override = port_override if port_override is not None else 0
9444        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9445        '''
9446         ID of the secret store containing credentials for this resource, if any.
9447        '''
9448        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9449        '''
9450         Tags is a map of key, value pairs.
9451        '''
9452        self.tls_required = tls_required if tls_required is not None else False
9453        self.username = username if username is not None else ''
9454
9455    def __repr__(self):
9456        return '<sdm.RabbitMQAMQP091 ' + \
9457            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9458            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9459            'healthy: ' + repr(self.healthy) + ' ' +\
9460            'hostname: ' + repr(self.hostname) + ' ' +\
9461            'id: ' + repr(self.id) + ' ' +\
9462            'name: ' + repr(self.name) + ' ' +\
9463            'password: ' + repr(self.password) + ' ' +\
9464            'port: ' + repr(self.port) + ' ' +\
9465            'port_override: ' + repr(self.port_override) + ' ' +\
9466            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9467            'tags: ' + repr(self.tags) + ' ' +\
9468            'tls_required: ' + repr(self.tls_required) + ' ' +\
9469            'username: ' + repr(self.username) + ' ' +\
9470            '>'
9471
9472    def to_dict(self):
9473        return {
9474            'bind_interface': self.bind_interface,
9475            'egress_filter': self.egress_filter,
9476            'healthy': self.healthy,
9477            'hostname': self.hostname,
9478            'id': self.id,
9479            'name': self.name,
9480            'password': self.password,
9481            'port': self.port,
9482            'port_override': self.port_override,
9483            'secret_store_id': self.secret_store_id,
9484            'tags': self.tags,
9485            'tls_required': self.tls_required,
9486            'username': self.username,
9487        }
9488
9489    @classmethod
9490    def from_dict(cls, d):
9491        return cls(
9492            bind_interface=d.get('bind_interface'),
9493            egress_filter=d.get('egress_filter'),
9494            healthy=d.get('healthy'),
9495            hostname=d.get('hostname'),
9496            id=d.get('id'),
9497            name=d.get('name'),
9498            password=d.get('password'),
9499            port=d.get('port'),
9500            port_override=d.get('port_override'),
9501            secret_store_id=d.get('secret_store_id'),
9502            tags=d.get('tags'),
9503            tls_required=d.get('tls_required'),
9504            username=d.get('username'),
9505        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9404    def __init__(
9405        self,
9406        bind_interface=None,
9407        egress_filter=None,
9408        healthy=None,
9409        hostname=None,
9410        id=None,
9411        name=None,
9412        password=None,
9413        port=None,
9414        port_override=None,
9415        secret_store_id=None,
9416        tags=None,
9417        tls_required=None,
9418        username=None,
9419    ):
9420        self.bind_interface = bind_interface if bind_interface is not None else ''
9421        '''
9422         Bind interface
9423        '''
9424        self.egress_filter = egress_filter if egress_filter is not None else ''
9425        '''
9426         A filter applied to the routing logic to pin datasource to nodes.
9427        '''
9428        self.healthy = healthy if healthy is not None else False
9429        '''
9430         True if the datasource is reachable and the credentials are valid.
9431        '''
9432        self.hostname = hostname if hostname is not None else ''
9433        self.id = id if id is not None else ''
9434        '''
9435         Unique identifier of the Resource.
9436        '''
9437        self.name = name if name is not None else ''
9438        '''
9439         Unique human-readable name of the Resource.
9440        '''
9441        self.password = password if password is not None else ''
9442        self.port = port if port is not None else 0
9443        self.port_override = port_override if port_override is not None else 0
9444        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9445        '''
9446         ID of the secret store containing credentials for this resource, if any.
9447        '''
9448        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9449        '''
9450         Tags is a map of key, value pairs.
9451        '''
9452        self.tls_required = tls_required if tls_required is not None else False
9453        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9472    def to_dict(self):
9473        return {
9474            'bind_interface': self.bind_interface,
9475            'egress_filter': self.egress_filter,
9476            'healthy': self.healthy,
9477            'hostname': self.hostname,
9478            'id': self.id,
9479            'name': self.name,
9480            'password': self.password,
9481            'port': self.port,
9482            'port_override': self.port_override,
9483            'secret_store_id': self.secret_store_id,
9484            'tags': self.tags,
9485            'tls_required': self.tls_required,
9486            'username': self.username,
9487        }
@classmethod
def from_dict(cls, d)
9489    @classmethod
9490    def from_dict(cls, d):
9491        return cls(
9492            bind_interface=d.get('bind_interface'),
9493            egress_filter=d.get('egress_filter'),
9494            healthy=d.get('healthy'),
9495            hostname=d.get('hostname'),
9496            id=d.get('id'),
9497            name=d.get('name'),
9498            password=d.get('password'),
9499            port=d.get('port'),
9500            port_override=d.get('port_override'),
9501            secret_store_id=d.get('secret_store_id'),
9502            tags=d.get('tags'),
9503            tls_required=d.get('tls_required'),
9504            username=d.get('username'),
9505        )
class RateLimitMetadata:
9508class RateLimitMetadata:
9509    '''
9510         RateLimitMetadata contains information about remaining requests avaialable
9511     to the user over some timeframe.
9512    '''
9513    __slots__ = [
9514        'bucket',
9515        'limit',
9516        'remaining',
9517        'reset_at',
9518    ]
9519
9520    def __init__(
9521        self,
9522        bucket=None,
9523        limit=None,
9524        remaining=None,
9525        reset_at=None,
9526    ):
9527        self.bucket = bucket if bucket is not None else ''
9528        '''
9529         The bucket this user/token is associated with, which may be shared between
9530         multiple users/tokens.
9531        '''
9532        self.limit = limit if limit is not None else 0
9533        '''
9534         How many total requests the user/token is authorized to make before being
9535         rate limited.
9536        '''
9537        self.remaining = remaining if remaining is not None else 0
9538        '''
9539         How many remaining requests out of the limit are still avaialable.
9540        '''
9541        self.reset_at = reset_at if reset_at is not None else None
9542        '''
9543         The time when remaining will be reset to limit.
9544        '''
9545
9546    def __repr__(self):
9547        return '<sdm.RateLimitMetadata ' + \
9548            'bucket: ' + repr(self.bucket) + ' ' +\
9549            'limit: ' + repr(self.limit) + ' ' +\
9550            'remaining: ' + repr(self.remaining) + ' ' +\
9551            'reset_at: ' + repr(self.reset_at) + ' ' +\
9552            '>'
9553
9554    def to_dict(self):
9555        return {
9556            'bucket': self.bucket,
9557            'limit': self.limit,
9558            'remaining': self.remaining,
9559            'reset_at': self.reset_at,
9560        }
9561
9562    @classmethod
9563    def from_dict(cls, d):
9564        return cls(
9565            bucket=d.get('bucket'),
9566            limit=d.get('limit'),
9567            remaining=d.get('remaining'),
9568            reset_at=d.get('reset_at'),
9569        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9520    def __init__(
9521        self,
9522        bucket=None,
9523        limit=None,
9524        remaining=None,
9525        reset_at=None,
9526    ):
9527        self.bucket = bucket if bucket is not None else ''
9528        '''
9529         The bucket this user/token is associated with, which may be shared between
9530         multiple users/tokens.
9531        '''
9532        self.limit = limit if limit is not None else 0
9533        '''
9534         How many total requests the user/token is authorized to make before being
9535         rate limited.
9536        '''
9537        self.remaining = remaining if remaining is not None else 0
9538        '''
9539         How many remaining requests out of the limit are still avaialable.
9540        '''
9541        self.reset_at = reset_at if reset_at is not None else None
9542        '''
9543         The time when remaining will be reset to limit.
9544        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9554    def to_dict(self):
9555        return {
9556            'bucket': self.bucket,
9557            'limit': self.limit,
9558            'remaining': self.remaining,
9559            'reset_at': self.reset_at,
9560        }
@classmethod
def from_dict(cls, d)
9562    @classmethod
9563    def from_dict(cls, d):
9564        return cls(
9565            bucket=d.get('bucket'),
9566            limit=d.get('limit'),
9567            remaining=d.get('remaining'),
9568            reset_at=d.get('reset_at'),
9569        )
class RawTCP:
9572class RawTCP:
9573    __slots__ = [
9574        'bind_interface',
9575        'egress_filter',
9576        'healthy',
9577        'hostname',
9578        'id',
9579        'name',
9580        'port',
9581        'port_override',
9582        'secret_store_id',
9583        'tags',
9584    ]
9585
9586    def __init__(
9587        self,
9588        bind_interface=None,
9589        egress_filter=None,
9590        healthy=None,
9591        hostname=None,
9592        id=None,
9593        name=None,
9594        port=None,
9595        port_override=None,
9596        secret_store_id=None,
9597        tags=None,
9598    ):
9599        self.bind_interface = bind_interface if bind_interface is not None else ''
9600        '''
9601         Bind interface
9602        '''
9603        self.egress_filter = egress_filter if egress_filter is not None else ''
9604        '''
9605         A filter applied to the routing logic to pin datasource to nodes.
9606        '''
9607        self.healthy = healthy if healthy is not None else False
9608        '''
9609         True if the datasource is reachable and the credentials are valid.
9610        '''
9611        self.hostname = hostname if hostname is not None else ''
9612        self.id = id if id is not None else ''
9613        '''
9614         Unique identifier of the Resource.
9615        '''
9616        self.name = name if name is not None else ''
9617        '''
9618         Unique human-readable name of the Resource.
9619        '''
9620        self.port = port if port is not None else 0
9621        self.port_override = port_override if port_override is not None else 0
9622        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9623        '''
9624         ID of the secret store containing credentials for this resource, if any.
9625        '''
9626        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9627        '''
9628         Tags is a map of key, value pairs.
9629        '''
9630
9631    def __repr__(self):
9632        return '<sdm.RawTCP ' + \
9633            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9634            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9635            'healthy: ' + repr(self.healthy) + ' ' +\
9636            'hostname: ' + repr(self.hostname) + ' ' +\
9637            'id: ' + repr(self.id) + ' ' +\
9638            'name: ' + repr(self.name) + ' ' +\
9639            'port: ' + repr(self.port) + ' ' +\
9640            'port_override: ' + repr(self.port_override) + ' ' +\
9641            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9642            'tags: ' + repr(self.tags) + ' ' +\
9643            '>'
9644
9645    def to_dict(self):
9646        return {
9647            'bind_interface': self.bind_interface,
9648            'egress_filter': self.egress_filter,
9649            'healthy': self.healthy,
9650            'hostname': self.hostname,
9651            'id': self.id,
9652            'name': self.name,
9653            'port': self.port,
9654            'port_override': self.port_override,
9655            'secret_store_id': self.secret_store_id,
9656            'tags': self.tags,
9657        }
9658
9659    @classmethod
9660    def from_dict(cls, d):
9661        return cls(
9662            bind_interface=d.get('bind_interface'),
9663            egress_filter=d.get('egress_filter'),
9664            healthy=d.get('healthy'),
9665            hostname=d.get('hostname'),
9666            id=d.get('id'),
9667            name=d.get('name'),
9668            port=d.get('port'),
9669            port_override=d.get('port_override'),
9670            secret_store_id=d.get('secret_store_id'),
9671            tags=d.get('tags'),
9672        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
9586    def __init__(
9587        self,
9588        bind_interface=None,
9589        egress_filter=None,
9590        healthy=None,
9591        hostname=None,
9592        id=None,
9593        name=None,
9594        port=None,
9595        port_override=None,
9596        secret_store_id=None,
9597        tags=None,
9598    ):
9599        self.bind_interface = bind_interface if bind_interface is not None else ''
9600        '''
9601         Bind interface
9602        '''
9603        self.egress_filter = egress_filter if egress_filter is not None else ''
9604        '''
9605         A filter applied to the routing logic to pin datasource to nodes.
9606        '''
9607        self.healthy = healthy if healthy is not None else False
9608        '''
9609         True if the datasource is reachable and the credentials are valid.
9610        '''
9611        self.hostname = hostname if hostname is not None else ''
9612        self.id = id if id is not None else ''
9613        '''
9614         Unique identifier of the Resource.
9615        '''
9616        self.name = name if name is not None else ''
9617        '''
9618         Unique human-readable name of the Resource.
9619        '''
9620        self.port = port if port is not None else 0
9621        self.port_override = port_override if port_override is not None else 0
9622        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9623        '''
9624         ID of the secret store containing credentials for this resource, if any.
9625        '''
9626        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9627        '''
9628         Tags is a map of key, value pairs.
9629        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9645    def to_dict(self):
9646        return {
9647            'bind_interface': self.bind_interface,
9648            'egress_filter': self.egress_filter,
9649            'healthy': self.healthy,
9650            'hostname': self.hostname,
9651            'id': self.id,
9652            'name': self.name,
9653            'port': self.port,
9654            'port_override': self.port_override,
9655            'secret_store_id': self.secret_store_id,
9656            'tags': self.tags,
9657        }
@classmethod
def from_dict(cls, d)
9659    @classmethod
9660    def from_dict(cls, d):
9661        return cls(
9662            bind_interface=d.get('bind_interface'),
9663            egress_filter=d.get('egress_filter'),
9664            healthy=d.get('healthy'),
9665            hostname=d.get('hostname'),
9666            id=d.get('id'),
9667            name=d.get('name'),
9668            port=d.get('port'),
9669            port_override=d.get('port_override'),
9670            secret_store_id=d.get('secret_store_id'),
9671            tags=d.get('tags'),
9672        )
class Redis:
9675class Redis:
9676    __slots__ = [
9677        'bind_interface',
9678        'egress_filter',
9679        'healthy',
9680        'hostname',
9681        'id',
9682        'name',
9683        'password',
9684        'port',
9685        'port_override',
9686        'secret_store_id',
9687        'tags',
9688        'tls_required',
9689        'username',
9690    ]
9691
9692    def __init__(
9693        self,
9694        bind_interface=None,
9695        egress_filter=None,
9696        healthy=None,
9697        hostname=None,
9698        id=None,
9699        name=None,
9700        password=None,
9701        port=None,
9702        port_override=None,
9703        secret_store_id=None,
9704        tags=None,
9705        tls_required=None,
9706        username=None,
9707    ):
9708        self.bind_interface = bind_interface if bind_interface is not None else ''
9709        '''
9710         Bind interface
9711        '''
9712        self.egress_filter = egress_filter if egress_filter is not None else ''
9713        '''
9714         A filter applied to the routing logic to pin datasource to nodes.
9715        '''
9716        self.healthy = healthy if healthy is not None else False
9717        '''
9718         True if the datasource is reachable and the credentials are valid.
9719        '''
9720        self.hostname = hostname if hostname is not None else ''
9721        self.id = id if id is not None else ''
9722        '''
9723         Unique identifier of the Resource.
9724        '''
9725        self.name = name if name is not None else ''
9726        '''
9727         Unique human-readable name of the Resource.
9728        '''
9729        self.password = password if password is not None else ''
9730        self.port = port if port is not None else 0
9731        self.port_override = port_override if port_override is not None else 0
9732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9733        '''
9734         ID of the secret store containing credentials for this resource, if any.
9735        '''
9736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9737        '''
9738         Tags is a map of key, value pairs.
9739        '''
9740        self.tls_required = tls_required if tls_required is not None else False
9741        self.username = username if username is not None else ''
9742
9743    def __repr__(self):
9744        return '<sdm.Redis ' + \
9745            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9747            'healthy: ' + repr(self.healthy) + ' ' +\
9748            'hostname: ' + repr(self.hostname) + ' ' +\
9749            'id: ' + repr(self.id) + ' ' +\
9750            'name: ' + repr(self.name) + ' ' +\
9751            'password: ' + repr(self.password) + ' ' +\
9752            'port: ' + repr(self.port) + ' ' +\
9753            'port_override: ' + repr(self.port_override) + ' ' +\
9754            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9755            'tags: ' + repr(self.tags) + ' ' +\
9756            'tls_required: ' + repr(self.tls_required) + ' ' +\
9757            'username: ' + repr(self.username) + ' ' +\
9758            '>'
9759
9760    def to_dict(self):
9761        return {
9762            'bind_interface': self.bind_interface,
9763            'egress_filter': self.egress_filter,
9764            'healthy': self.healthy,
9765            'hostname': self.hostname,
9766            'id': self.id,
9767            'name': self.name,
9768            'password': self.password,
9769            'port': self.port,
9770            'port_override': self.port_override,
9771            'secret_store_id': self.secret_store_id,
9772            'tags': self.tags,
9773            'tls_required': self.tls_required,
9774            'username': self.username,
9775        }
9776
9777    @classmethod
9778    def from_dict(cls, d):
9779        return cls(
9780            bind_interface=d.get('bind_interface'),
9781            egress_filter=d.get('egress_filter'),
9782            healthy=d.get('healthy'),
9783            hostname=d.get('hostname'),
9784            id=d.get('id'),
9785            name=d.get('name'),
9786            password=d.get('password'),
9787            port=d.get('port'),
9788            port_override=d.get('port_override'),
9789            secret_store_id=d.get('secret_store_id'),
9790            tags=d.get('tags'),
9791            tls_required=d.get('tls_required'),
9792            username=d.get('username'),
9793        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9692    def __init__(
9693        self,
9694        bind_interface=None,
9695        egress_filter=None,
9696        healthy=None,
9697        hostname=None,
9698        id=None,
9699        name=None,
9700        password=None,
9701        port=None,
9702        port_override=None,
9703        secret_store_id=None,
9704        tags=None,
9705        tls_required=None,
9706        username=None,
9707    ):
9708        self.bind_interface = bind_interface if bind_interface is not None else ''
9709        '''
9710         Bind interface
9711        '''
9712        self.egress_filter = egress_filter if egress_filter is not None else ''
9713        '''
9714         A filter applied to the routing logic to pin datasource to nodes.
9715        '''
9716        self.healthy = healthy if healthy is not None else False
9717        '''
9718         True if the datasource is reachable and the credentials are valid.
9719        '''
9720        self.hostname = hostname if hostname is not None else ''
9721        self.id = id if id is not None else ''
9722        '''
9723         Unique identifier of the Resource.
9724        '''
9725        self.name = name if name is not None else ''
9726        '''
9727         Unique human-readable name of the Resource.
9728        '''
9729        self.password = password if password is not None else ''
9730        self.port = port if port is not None else 0
9731        self.port_override = port_override if port_override is not None else 0
9732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9733        '''
9734         ID of the secret store containing credentials for this resource, if any.
9735        '''
9736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9737        '''
9738         Tags is a map of key, value pairs.
9739        '''
9740        self.tls_required = tls_required if tls_required is not None else False
9741        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9760    def to_dict(self):
9761        return {
9762            'bind_interface': self.bind_interface,
9763            'egress_filter': self.egress_filter,
9764            'healthy': self.healthy,
9765            'hostname': self.hostname,
9766            'id': self.id,
9767            'name': self.name,
9768            'password': self.password,
9769            'port': self.port,
9770            'port_override': self.port_override,
9771            'secret_store_id': self.secret_store_id,
9772            'tags': self.tags,
9773            'tls_required': self.tls_required,
9774            'username': self.username,
9775        }
@classmethod
def from_dict(cls, d)
9777    @classmethod
9778    def from_dict(cls, d):
9779        return cls(
9780            bind_interface=d.get('bind_interface'),
9781            egress_filter=d.get('egress_filter'),
9782            healthy=d.get('healthy'),
9783            hostname=d.get('hostname'),
9784            id=d.get('id'),
9785            name=d.get('name'),
9786            password=d.get('password'),
9787            port=d.get('port'),
9788            port_override=d.get('port_override'),
9789            secret_store_id=d.get('secret_store_id'),
9790            tags=d.get('tags'),
9791            tls_required=d.get('tls_required'),
9792            username=d.get('username'),
9793        )
class Redshift:
9796class Redshift:
9797    __slots__ = [
9798        'bind_interface',
9799        'database',
9800        'egress_filter',
9801        'healthy',
9802        'hostname',
9803        'id',
9804        'name',
9805        'override_database',
9806        'password',
9807        'port',
9808        'port_override',
9809        'secret_store_id',
9810        'tags',
9811        'username',
9812    ]
9813
9814    def __init__(
9815        self,
9816        bind_interface=None,
9817        database=None,
9818        egress_filter=None,
9819        healthy=None,
9820        hostname=None,
9821        id=None,
9822        name=None,
9823        override_database=None,
9824        password=None,
9825        port=None,
9826        port_override=None,
9827        secret_store_id=None,
9828        tags=None,
9829        username=None,
9830    ):
9831        self.bind_interface = bind_interface if bind_interface is not None else ''
9832        '''
9833         Bind interface
9834        '''
9835        self.database = database if database is not None else ''
9836        self.egress_filter = egress_filter if egress_filter is not None else ''
9837        '''
9838         A filter applied to the routing logic to pin datasource to nodes.
9839        '''
9840        self.healthy = healthy if healthy is not None else False
9841        '''
9842         True if the datasource is reachable and the credentials are valid.
9843        '''
9844        self.hostname = hostname if hostname is not None else ''
9845        self.id = id if id is not None else ''
9846        '''
9847         Unique identifier of the Resource.
9848        '''
9849        self.name = name if name is not None else ''
9850        '''
9851         Unique human-readable name of the Resource.
9852        '''
9853        self.override_database = override_database if override_database is not None else False
9854        self.password = password if password is not None else ''
9855        self.port = port if port is not None else 0
9856        self.port_override = port_override if port_override is not None else 0
9857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9858        '''
9859         ID of the secret store containing credentials for this resource, if any.
9860        '''
9861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9862        '''
9863         Tags is a map of key, value pairs.
9864        '''
9865        self.username = username if username is not None else ''
9866
9867    def __repr__(self):
9868        return '<sdm.Redshift ' + \
9869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9870            'database: ' + repr(self.database) + ' ' +\
9871            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9872            'healthy: ' + repr(self.healthy) + ' ' +\
9873            'hostname: ' + repr(self.hostname) + ' ' +\
9874            'id: ' + repr(self.id) + ' ' +\
9875            'name: ' + repr(self.name) + ' ' +\
9876            'override_database: ' + repr(self.override_database) + ' ' +\
9877            'password: ' + repr(self.password) + ' ' +\
9878            'port: ' + repr(self.port) + ' ' +\
9879            'port_override: ' + repr(self.port_override) + ' ' +\
9880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9881            'tags: ' + repr(self.tags) + ' ' +\
9882            'username: ' + repr(self.username) + ' ' +\
9883            '>'
9884
9885    def to_dict(self):
9886        return {
9887            'bind_interface': self.bind_interface,
9888            'database': self.database,
9889            'egress_filter': self.egress_filter,
9890            'healthy': self.healthy,
9891            'hostname': self.hostname,
9892            'id': self.id,
9893            'name': self.name,
9894            'override_database': self.override_database,
9895            'password': self.password,
9896            'port': self.port,
9897            'port_override': self.port_override,
9898            'secret_store_id': self.secret_store_id,
9899            'tags': self.tags,
9900            'username': self.username,
9901        }
9902
9903    @classmethod
9904    def from_dict(cls, d):
9905        return cls(
9906            bind_interface=d.get('bind_interface'),
9907            database=d.get('database'),
9908            egress_filter=d.get('egress_filter'),
9909            healthy=d.get('healthy'),
9910            hostname=d.get('hostname'),
9911            id=d.get('id'),
9912            name=d.get('name'),
9913            override_database=d.get('override_database'),
9914            password=d.get('password'),
9915            port=d.get('port'),
9916            port_override=d.get('port_override'),
9917            secret_store_id=d.get('secret_store_id'),
9918            tags=d.get('tags'),
9919            username=d.get('username'),
9920        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9814    def __init__(
9815        self,
9816        bind_interface=None,
9817        database=None,
9818        egress_filter=None,
9819        healthy=None,
9820        hostname=None,
9821        id=None,
9822        name=None,
9823        override_database=None,
9824        password=None,
9825        port=None,
9826        port_override=None,
9827        secret_store_id=None,
9828        tags=None,
9829        username=None,
9830    ):
9831        self.bind_interface = bind_interface if bind_interface is not None else ''
9832        '''
9833         Bind interface
9834        '''
9835        self.database = database if database is not None else ''
9836        self.egress_filter = egress_filter if egress_filter is not None else ''
9837        '''
9838         A filter applied to the routing logic to pin datasource to nodes.
9839        '''
9840        self.healthy = healthy if healthy is not None else False
9841        '''
9842         True if the datasource is reachable and the credentials are valid.
9843        '''
9844        self.hostname = hostname if hostname is not None else ''
9845        self.id = id if id is not None else ''
9846        '''
9847         Unique identifier of the Resource.
9848        '''
9849        self.name = name if name is not None else ''
9850        '''
9851         Unique human-readable name of the Resource.
9852        '''
9853        self.override_database = override_database if override_database is not None else False
9854        self.password = password if password is not None else ''
9855        self.port = port if port is not None else 0
9856        self.port_override = port_override if port_override is not None else 0
9857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9858        '''
9859         ID of the secret store containing credentials for this resource, if any.
9860        '''
9861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9862        '''
9863         Tags is a map of key, value pairs.
9864        '''
9865        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9885    def to_dict(self):
9886        return {
9887            'bind_interface': self.bind_interface,
9888            'database': self.database,
9889            'egress_filter': self.egress_filter,
9890            'healthy': self.healthy,
9891            'hostname': self.hostname,
9892            'id': self.id,
9893            'name': self.name,
9894            'override_database': self.override_database,
9895            'password': self.password,
9896            'port': self.port,
9897            'port_override': self.port_override,
9898            'secret_store_id': self.secret_store_id,
9899            'tags': self.tags,
9900            'username': self.username,
9901        }
@classmethod
def from_dict(cls, d)
9903    @classmethod
9904    def from_dict(cls, d):
9905        return cls(
9906            bind_interface=d.get('bind_interface'),
9907            database=d.get('database'),
9908            egress_filter=d.get('egress_filter'),
9909            healthy=d.get('healthy'),
9910            hostname=d.get('hostname'),
9911            id=d.get('id'),
9912            name=d.get('name'),
9913            override_database=d.get('override_database'),
9914            password=d.get('password'),
9915            port=d.get('port'),
9916            port_override=d.get('port_override'),
9917            secret_store_id=d.get('secret_store_id'),
9918            tags=d.get('tags'),
9919            username=d.get('username'),
9920        )
class Relay:
 9923class Relay:
 9924    '''
 9925         Relay represents a StrongDM CLI installation running in relay mode.
 9926    '''
 9927    __slots__ = [
 9928        'device',
 9929        'gateway_filter',
 9930        'id',
 9931        'location',
 9932        'name',
 9933        'state',
 9934        'tags',
 9935        'version',
 9936    ]
 9937
 9938    def __init__(
 9939        self,
 9940        device=None,
 9941        gateway_filter=None,
 9942        id=None,
 9943        location=None,
 9944        name=None,
 9945        state=None,
 9946        tags=None,
 9947        version=None,
 9948    ):
 9949        self.device = device if device is not None else ''
 9950        '''
 9951         Device is a read only device name uploaded by the gateway process when 
 9952         it comes online.
 9953        '''
 9954        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9955        '''
 9956         GatewayFilter can be used to restrict the peering between relays and
 9957         gateways.
 9958        '''
 9959        self.id = id if id is not None else ''
 9960        '''
 9961         Unique identifier of the Relay.
 9962        '''
 9963        self.location = location if location is not None else ''
 9964        '''
 9965         Location is a read only network location uploaded by the gateway process
 9966         when it comes online.
 9967        '''
 9968        self.name = name if name is not None else ''
 9969        '''
 9970         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9971        '''
 9972        self.state = state if state is not None else ''
 9973        '''
 9974         The current state of the relay. One of: "new", "verifying_restart",
 9975         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9976         "unknown".
 9977        '''
 9978        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9979        '''
 9980         Tags is a map of key, value pairs.
 9981        '''
 9982        self.version = version if version is not None else ''
 9983        '''
 9984         Version is a read only sdm binary version uploaded by the gateway process
 9985         when it comes online.
 9986        '''
 9987
 9988    def __repr__(self):
 9989        return '<sdm.Relay ' + \
 9990            'device: ' + repr(self.device) + ' ' +\
 9991            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9992            'id: ' + repr(self.id) + ' ' +\
 9993            'location: ' + repr(self.location) + ' ' +\
 9994            'name: ' + repr(self.name) + ' ' +\
 9995            'state: ' + repr(self.state) + ' ' +\
 9996            'tags: ' + repr(self.tags) + ' ' +\
 9997            'version: ' + repr(self.version) + ' ' +\
 9998            '>'
 9999
10000    def to_dict(self):
10001        return {
10002            'device': self.device,
10003            'gateway_filter': self.gateway_filter,
10004            'id': self.id,
10005            'location': self.location,
10006            'name': self.name,
10007            'state': self.state,
10008            'tags': self.tags,
10009            'version': self.version,
10010        }
10011
10012    @classmethod
10013    def from_dict(cls, d):
10014        return cls(
10015            device=d.get('device'),
10016            gateway_filter=d.get('gateway_filter'),
10017            id=d.get('id'),
10018            location=d.get('location'),
10019            name=d.get('name'),
10020            state=d.get('state'),
10021            tags=d.get('tags'),
10022            version=d.get('version'),
10023        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay( device=None, gateway_filter=None, id=None, location=None, name=None, state=None, tags=None, version=None)
9938    def __init__(
9939        self,
9940        device=None,
9941        gateway_filter=None,
9942        id=None,
9943        location=None,
9944        name=None,
9945        state=None,
9946        tags=None,
9947        version=None,
9948    ):
9949        self.device = device if device is not None else ''
9950        '''
9951         Device is a read only device name uploaded by the gateway process when 
9952         it comes online.
9953        '''
9954        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9955        '''
9956         GatewayFilter can be used to restrict the peering between relays and
9957         gateways.
9958        '''
9959        self.id = id if id is not None else ''
9960        '''
9961         Unique identifier of the Relay.
9962        '''
9963        self.location = location if location is not None else ''
9964        '''
9965         Location is a read only network location uploaded by the gateway process
9966         when it comes online.
9967        '''
9968        self.name = name if name is not None else ''
9969        '''
9970         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9971        '''
9972        self.state = state if state is not None else ''
9973        '''
9974         The current state of the relay. One of: "new", "verifying_restart",
9975         "awaiting_restart", "restarting", "started", "stopped", "dead",
9976         "unknown".
9977        '''
9978        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9979        '''
9980         Tags is a map of key, value pairs.
9981        '''
9982        self.version = version if version is not None else ''
9983        '''
9984         Version is a read only sdm binary version uploaded by the gateway process
9985         when it comes online.
9986        '''
device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
10000    def to_dict(self):
10001        return {
10002            'device': self.device,
10003            'gateway_filter': self.gateway_filter,
10004            'id': self.id,
10005            'location': self.location,
10006            'name': self.name,
10007            'state': self.state,
10008            'tags': self.tags,
10009            'version': self.version,
10010        }
@classmethod
def from_dict(cls, d)
10012    @classmethod
10013    def from_dict(cls, d):
10014        return cls(
10015            device=d.get('device'),
10016            gateway_filter=d.get('gateway_filter'),
10017            id=d.get('id'),
10018            location=d.get('location'),
10019            name=d.get('name'),
10020            state=d.get('state'),
10021            tags=d.get('tags'),
10022            version=d.get('version'),
10023        )
class RemoteIdentity:
10026class RemoteIdentity:
10027    '''
10028         RemoteIdentities define the username to be used for a specific account
10029     when connecting to a remote resource using that group.
10030    '''
10031    __slots__ = [
10032        'account_id',
10033        'id',
10034        'remote_identity_group_id',
10035        'username',
10036    ]
10037
10038    def __init__(
10039        self,
10040        account_id=None,
10041        id=None,
10042        remote_identity_group_id=None,
10043        username=None,
10044    ):
10045        self.account_id = account_id if account_id is not None else ''
10046        '''
10047         The account for this remote identity.
10048        '''
10049        self.id = id if id is not None else ''
10050        '''
10051         Unique identifier of the RemoteIdentity.
10052        '''
10053        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10054        '''
10055         The remote identity group.
10056        '''
10057        self.username = username if username is not None else ''
10058        '''
10059         The username to be used as the remote identity for this account.
10060        '''
10061
10062    def __repr__(self):
10063        return '<sdm.RemoteIdentity ' + \
10064            'account_id: ' + repr(self.account_id) + ' ' +\
10065            'id: ' + repr(self.id) + ' ' +\
10066            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10067            'username: ' + repr(self.username) + ' ' +\
10068            '>'
10069
10070    def to_dict(self):
10071        return {
10072            'account_id': self.account_id,
10073            'id': self.id,
10074            'remote_identity_group_id': self.remote_identity_group_id,
10075            'username': self.username,
10076        }
10077
10078    @classmethod
10079    def from_dict(cls, d):
10080        return cls(
10081            account_id=d.get('account_id'),
10082            id=d.get('id'),
10083            remote_identity_group_id=d.get('remote_identity_group_id'),
10084            username=d.get('username'),
10085        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
10038    def __init__(
10039        self,
10040        account_id=None,
10041        id=None,
10042        remote_identity_group_id=None,
10043        username=None,
10044    ):
10045        self.account_id = account_id if account_id is not None else ''
10046        '''
10047         The account for this remote identity.
10048        '''
10049        self.id = id if id is not None else ''
10050        '''
10051         Unique identifier of the RemoteIdentity.
10052        '''
10053        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10054        '''
10055         The remote identity group.
10056        '''
10057        self.username = username if username is not None else ''
10058        '''
10059         The username to be used as the remote identity for this account.
10060        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
10070    def to_dict(self):
10071        return {
10072            'account_id': self.account_id,
10073            'id': self.id,
10074            'remote_identity_group_id': self.remote_identity_group_id,
10075            'username': self.username,
10076        }
@classmethod
def from_dict(cls, d)
10078    @classmethod
10079    def from_dict(cls, d):
10080        return cls(
10081            account_id=d.get('account_id'),
10082            id=d.get('id'),
10083            remote_identity_group_id=d.get('remote_identity_group_id'),
10084            username=d.get('username'),
10085        )
class RemoteIdentityCreateResponse:
10088class RemoteIdentityCreateResponse:
10089    '''
10090         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10091    '''
10092    __slots__ = [
10093        'meta',
10094        'rate_limit',
10095        'remote_identity',
10096    ]
10097
10098    def __init__(
10099        self,
10100        meta=None,
10101        rate_limit=None,
10102        remote_identity=None,
10103    ):
10104        self.meta = meta if meta is not None else None
10105        '''
10106         Reserved for future use.
10107        '''
10108        self.rate_limit = rate_limit if rate_limit is not None else None
10109        '''
10110         Rate limit information.
10111        '''
10112        self.remote_identity = remote_identity if remote_identity is not None else None
10113        '''
10114         The created RemoteIdentity.
10115        '''
10116
10117    def __repr__(self):
10118        return '<sdm.RemoteIdentityCreateResponse ' + \
10119            'meta: ' + repr(self.meta) + ' ' +\
10120            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10121            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10122            '>'
10123
10124    def to_dict(self):
10125        return {
10126            'meta': self.meta,
10127            'rate_limit': self.rate_limit,
10128            'remote_identity': self.remote_identity,
10129        }
10130
10131    @classmethod
10132    def from_dict(cls, d):
10133        return cls(
10134            meta=d.get('meta'),
10135            rate_limit=d.get('rate_limit'),
10136            remote_identity=d.get('remote_identity'),
10137        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
10098    def __init__(
10099        self,
10100        meta=None,
10101        rate_limit=None,
10102        remote_identity=None,
10103    ):
10104        self.meta = meta if meta is not None else None
10105        '''
10106         Reserved for future use.
10107        '''
10108        self.rate_limit = rate_limit if rate_limit is not None else None
10109        '''
10110         Rate limit information.
10111        '''
10112        self.remote_identity = remote_identity if remote_identity is not None else None
10113        '''
10114         The created RemoteIdentity.
10115        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
10124    def to_dict(self):
10125        return {
10126            'meta': self.meta,
10127            'rate_limit': self.rate_limit,
10128            'remote_identity': self.remote_identity,
10129        }
@classmethod
def from_dict(cls, d)
10131    @classmethod
10132    def from_dict(cls, d):
10133        return cls(
10134            meta=d.get('meta'),
10135            rate_limit=d.get('rate_limit'),
10136            remote_identity=d.get('remote_identity'),
10137        )
class RemoteIdentityDeleteResponse:
10140class RemoteIdentityDeleteResponse:
10141    '''
10142         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10143    '''
10144    __slots__ = [
10145        'meta',
10146        'rate_limit',
10147    ]
10148
10149    def __init__(
10150        self,
10151        meta=None,
10152        rate_limit=None,
10153    ):
10154        self.meta = meta if meta is not None else None
10155        '''
10156         Reserved for future use.
10157        '''
10158        self.rate_limit = rate_limit if rate_limit is not None else None
10159        '''
10160         Rate limit information.
10161        '''
10162
10163    def __repr__(self):
10164        return '<sdm.RemoteIdentityDeleteResponse ' + \
10165            'meta: ' + repr(self.meta) + ' ' +\
10166            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10167            '>'
10168
10169    def to_dict(self):
10170        return {
10171            'meta': self.meta,
10172            'rate_limit': self.rate_limit,
10173        }
10174
10175    @classmethod
10176    def from_dict(cls, d):
10177        return cls(
10178            meta=d.get('meta'),
10179            rate_limit=d.get('rate_limit'),
10180        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
10149    def __init__(
10150        self,
10151        meta=None,
10152        rate_limit=None,
10153    ):
10154        self.meta = meta if meta is not None else None
10155        '''
10156         Reserved for future use.
10157        '''
10158        self.rate_limit = rate_limit if rate_limit is not None else None
10159        '''
10160         Rate limit information.
10161        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10169    def to_dict(self):
10170        return {
10171            'meta': self.meta,
10172            'rate_limit': self.rate_limit,
10173        }
@classmethod
def from_dict(cls, d)
10175    @classmethod
10176    def from_dict(cls, d):
10177        return cls(
10178            meta=d.get('meta'),
10179            rate_limit=d.get('rate_limit'),
10180        )
class RemoteIdentityGetResponse:
10183class RemoteIdentityGetResponse:
10184    '''
10185         RemoteIdentityGetResponse returns a requested RemoteIdentity.
10186    '''
10187    __slots__ = [
10188        'meta',
10189        'rate_limit',
10190        'remote_identity',
10191    ]
10192
10193    def __init__(
10194        self,
10195        meta=None,
10196        rate_limit=None,
10197        remote_identity=None,
10198    ):
10199        self.meta = meta if meta is not None else None
10200        '''
10201         Reserved for future use.
10202        '''
10203        self.rate_limit = rate_limit if rate_limit is not None else None
10204        '''
10205         Rate limit information.
10206        '''
10207        self.remote_identity = remote_identity if remote_identity is not None else None
10208        '''
10209         The requested RemoteIdentity.
10210        '''
10211
10212    def __repr__(self):
10213        return '<sdm.RemoteIdentityGetResponse ' + \
10214            'meta: ' + repr(self.meta) + ' ' +\
10215            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10216            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10217            '>'
10218
10219    def to_dict(self):
10220        return {
10221            'meta': self.meta,
10222            'rate_limit': self.rate_limit,
10223            'remote_identity': self.remote_identity,
10224        }
10225
10226    @classmethod
10227    def from_dict(cls, d):
10228        return cls(
10229            meta=d.get('meta'),
10230            rate_limit=d.get('rate_limit'),
10231            remote_identity=d.get('remote_identity'),
10232        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
10193    def __init__(
10194        self,
10195        meta=None,
10196        rate_limit=None,
10197        remote_identity=None,
10198    ):
10199        self.meta = meta if meta is not None else None
10200        '''
10201         Reserved for future use.
10202        '''
10203        self.rate_limit = rate_limit if rate_limit is not None else None
10204        '''
10205         Rate limit information.
10206        '''
10207        self.remote_identity = remote_identity if remote_identity is not None else None
10208        '''
10209         The requested RemoteIdentity.
10210        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10219    def to_dict(self):
10220        return {
10221            'meta': self.meta,
10222            'rate_limit': self.rate_limit,
10223            'remote_identity': self.remote_identity,
10224        }
@classmethod
def from_dict(cls, d)
10226    @classmethod
10227    def from_dict(cls, d):
10228        return cls(
10229            meta=d.get('meta'),
10230            rate_limit=d.get('rate_limit'),
10231            remote_identity=d.get('remote_identity'),
10232        )
class RemoteIdentityGroup:
10235class RemoteIdentityGroup:
10236    '''
10237         A RemoteIdentityGroup defines a group of remote identities.
10238    '''
10239    __slots__ = [
10240        'id',
10241        'name',
10242    ]
10243
10244    def __init__(
10245        self,
10246        id=None,
10247        name=None,
10248    ):
10249        self.id = id if id is not None else ''
10250        '''
10251         Unique identifier of the RemoteIdentityGroup.
10252        '''
10253        self.name = name if name is not None else ''
10254        '''
10255         Unique human-readable name of the RemoteIdentityGroup.
10256        '''
10257
10258    def __repr__(self):
10259        return '<sdm.RemoteIdentityGroup ' + \
10260            'id: ' + repr(self.id) + ' ' +\
10261            'name: ' + repr(self.name) + ' ' +\
10262            '>'
10263
10264    def to_dict(self):
10265        return {
10266            'id': self.id,
10267            'name': self.name,
10268        }
10269
10270    @classmethod
10271    def from_dict(cls, d):
10272        return cls(
10273            id=d.get('id'),
10274            name=d.get('name'),
10275        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10244    def __init__(
10245        self,
10246        id=None,
10247        name=None,
10248    ):
10249        self.id = id if id is not None else ''
10250        '''
10251         Unique identifier of the RemoteIdentityGroup.
10252        '''
10253        self.name = name if name is not None else ''
10254        '''
10255         Unique human-readable name of the RemoteIdentityGroup.
10256        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10264    def to_dict(self):
10265        return {
10266            'id': self.id,
10267            'name': self.name,
10268        }
@classmethod
def from_dict(cls, d)
10270    @classmethod
10271    def from_dict(cls, d):
10272        return cls(
10273            id=d.get('id'),
10274            name=d.get('name'),
10275        )
class RemoteIdentityGroupGetResponse:
10278class RemoteIdentityGroupGetResponse:
10279    '''
10280         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10281    '''
10282    __slots__ = [
10283        'meta',
10284        'rate_limit',
10285        'remote_identity_group',
10286    ]
10287
10288    def __init__(
10289        self,
10290        meta=None,
10291        rate_limit=None,
10292        remote_identity_group=None,
10293    ):
10294        self.meta = meta if meta is not None else None
10295        '''
10296         Reserved for future use.
10297        '''
10298        self.rate_limit = rate_limit if rate_limit is not None else None
10299        '''
10300         Rate limit information.
10301        '''
10302        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10303        '''
10304         The requested RemoteIdentityGroup.
10305        '''
10306
10307    def __repr__(self):
10308        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10309            'meta: ' + repr(self.meta) + ' ' +\
10310            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10311            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10312            '>'
10313
10314    def to_dict(self):
10315        return {
10316            'meta': self.meta,
10317            'rate_limit': self.rate_limit,
10318            'remote_identity_group': self.remote_identity_group,
10319        }
10320
10321    @classmethod
10322    def from_dict(cls, d):
10323        return cls(
10324            meta=d.get('meta'),
10325            rate_limit=d.get('rate_limit'),
10326            remote_identity_group=d.get('remote_identity_group'),
10327        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10288    def __init__(
10289        self,
10290        meta=None,
10291        rate_limit=None,
10292        remote_identity_group=None,
10293    ):
10294        self.meta = meta if meta is not None else None
10295        '''
10296         Reserved for future use.
10297        '''
10298        self.rate_limit = rate_limit if rate_limit is not None else None
10299        '''
10300         Rate limit information.
10301        '''
10302        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10303        '''
10304         The requested RemoteIdentityGroup.
10305        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10314    def to_dict(self):
10315        return {
10316            'meta': self.meta,
10317            'rate_limit': self.rate_limit,
10318            'remote_identity_group': self.remote_identity_group,
10319        }
@classmethod
def from_dict(cls, d)
10321    @classmethod
10322    def from_dict(cls, d):
10323        return cls(
10324            meta=d.get('meta'),
10325            rate_limit=d.get('rate_limit'),
10326            remote_identity_group=d.get('remote_identity_group'),
10327        )
class RemoteIdentityUpdateResponse:
10330class RemoteIdentityUpdateResponse:
10331    '''
10332         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10333     a RemoteIdentityUpdateRequest.
10334    '''
10335    __slots__ = [
10336        'meta',
10337        'rate_limit',
10338        'remote_identity',
10339    ]
10340
10341    def __init__(
10342        self,
10343        meta=None,
10344        rate_limit=None,
10345        remote_identity=None,
10346    ):
10347        self.meta = meta if meta is not None else None
10348        '''
10349         Reserved for future use.
10350        '''
10351        self.rate_limit = rate_limit if rate_limit is not None else None
10352        '''
10353         Rate limit information.
10354        '''
10355        self.remote_identity = remote_identity if remote_identity is not None else None
10356        '''
10357         The updated RemoteIdentity.
10358        '''
10359
10360    def __repr__(self):
10361        return '<sdm.RemoteIdentityUpdateResponse ' + \
10362            'meta: ' + repr(self.meta) + ' ' +\
10363            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10364            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10365            '>'
10366
10367    def to_dict(self):
10368        return {
10369            'meta': self.meta,
10370            'rate_limit': self.rate_limit,
10371            'remote_identity': self.remote_identity,
10372        }
10373
10374    @classmethod
10375    def from_dict(cls, d):
10376        return cls(
10377            meta=d.get('meta'),
10378            rate_limit=d.get('rate_limit'),
10379            remote_identity=d.get('remote_identity'),
10380        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10341    def __init__(
10342        self,
10343        meta=None,
10344        rate_limit=None,
10345        remote_identity=None,
10346    ):
10347        self.meta = meta if meta is not None else None
10348        '''
10349         Reserved for future use.
10350        '''
10351        self.rate_limit = rate_limit if rate_limit is not None else None
10352        '''
10353         Rate limit information.
10354        '''
10355        self.remote_identity = remote_identity if remote_identity is not None else None
10356        '''
10357         The updated RemoteIdentity.
10358        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10367    def to_dict(self):
10368        return {
10369            'meta': self.meta,
10370            'rate_limit': self.rate_limit,
10371            'remote_identity': self.remote_identity,
10372        }
@classmethod
def from_dict(cls, d)
10374    @classmethod
10375    def from_dict(cls, d):
10376        return cls(
10377            meta=d.get('meta'),
10378            rate_limit=d.get('rate_limit'),
10379            remote_identity=d.get('remote_identity'),
10380        )
class ResourceCreateResponse:
10383class ResourceCreateResponse:
10384    '''
10385         ResourceCreateResponse reports how the Resources were created in the system.
10386    '''
10387    __slots__ = [
10388        'meta',
10389        'rate_limit',
10390        'resource',
10391    ]
10392
10393    def __init__(
10394        self,
10395        meta=None,
10396        rate_limit=None,
10397        resource=None,
10398    ):
10399        self.meta = meta if meta is not None else None
10400        '''
10401         Reserved for future use.
10402        '''
10403        self.rate_limit = rate_limit if rate_limit is not None else None
10404        '''
10405         Rate limit information.
10406        '''
10407        self.resource = resource if resource is not None else None
10408        '''
10409         The created Resource.
10410        '''
10411
10412    def __repr__(self):
10413        return '<sdm.ResourceCreateResponse ' + \
10414            'meta: ' + repr(self.meta) + ' ' +\
10415            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10416            'resource: ' + repr(self.resource) + ' ' +\
10417            '>'
10418
10419    def to_dict(self):
10420        return {
10421            'meta': self.meta,
10422            'rate_limit': self.rate_limit,
10423            'resource': self.resource,
10424        }
10425
10426    @classmethod
10427    def from_dict(cls, d):
10428        return cls(
10429            meta=d.get('meta'),
10430            rate_limit=d.get('rate_limit'),
10431            resource=d.get('resource'),
10432        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10393    def __init__(
10394        self,
10395        meta=None,
10396        rate_limit=None,
10397        resource=None,
10398    ):
10399        self.meta = meta if meta is not None else None
10400        '''
10401         Reserved for future use.
10402        '''
10403        self.rate_limit = rate_limit if rate_limit is not None else None
10404        '''
10405         Rate limit information.
10406        '''
10407        self.resource = resource if resource is not None else None
10408        '''
10409         The created Resource.
10410        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10419    def to_dict(self):
10420        return {
10421            'meta': self.meta,
10422            'rate_limit': self.rate_limit,
10423            'resource': self.resource,
10424        }
@classmethod
def from_dict(cls, d)
10426    @classmethod
10427    def from_dict(cls, d):
10428        return cls(
10429            meta=d.get('meta'),
10430            rate_limit=d.get('rate_limit'),
10431            resource=d.get('resource'),
10432        )
class ResourceDeleteResponse:
10435class ResourceDeleteResponse:
10436    '''
10437         ResourceDeleteResponse returns information about a Resource that was deleted.
10438    '''
10439    __slots__ = [
10440        'meta',
10441        'rate_limit',
10442    ]
10443
10444    def __init__(
10445        self,
10446        meta=None,
10447        rate_limit=None,
10448    ):
10449        self.meta = meta if meta is not None else None
10450        '''
10451         Reserved for future use.
10452        '''
10453        self.rate_limit = rate_limit if rate_limit is not None else None
10454        '''
10455         Rate limit information.
10456        '''
10457
10458    def __repr__(self):
10459        return '<sdm.ResourceDeleteResponse ' + \
10460            'meta: ' + repr(self.meta) + ' ' +\
10461            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10462            '>'
10463
10464    def to_dict(self):
10465        return {
10466            'meta': self.meta,
10467            'rate_limit': self.rate_limit,
10468        }
10469
10470    @classmethod
10471    def from_dict(cls, d):
10472        return cls(
10473            meta=d.get('meta'),
10474            rate_limit=d.get('rate_limit'),
10475        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10444    def __init__(
10445        self,
10446        meta=None,
10447        rate_limit=None,
10448    ):
10449        self.meta = meta if meta is not None else None
10450        '''
10451         Reserved for future use.
10452        '''
10453        self.rate_limit = rate_limit if rate_limit is not None else None
10454        '''
10455         Rate limit information.
10456        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10464    def to_dict(self):
10465        return {
10466            'meta': self.meta,
10467            'rate_limit': self.rate_limit,
10468        }
@classmethod
def from_dict(cls, d)
10470    @classmethod
10471    def from_dict(cls, d):
10472        return cls(
10473            meta=d.get('meta'),
10474            rate_limit=d.get('rate_limit'),
10475        )
class ResourceGetResponse:
10478class ResourceGetResponse:
10479    '''
10480         ResourceGetResponse returns a requested Resource.
10481    '''
10482    __slots__ = [
10483        'meta',
10484        'rate_limit',
10485        'resource',
10486    ]
10487
10488    def __init__(
10489        self,
10490        meta=None,
10491        rate_limit=None,
10492        resource=None,
10493    ):
10494        self.meta = meta if meta is not None else None
10495        '''
10496         Reserved for future use.
10497        '''
10498        self.rate_limit = rate_limit if rate_limit is not None else None
10499        '''
10500         Rate limit information.
10501        '''
10502        self.resource = resource if resource is not None else None
10503        '''
10504         The requested Resource.
10505        '''
10506
10507    def __repr__(self):
10508        return '<sdm.ResourceGetResponse ' + \
10509            'meta: ' + repr(self.meta) + ' ' +\
10510            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10511            'resource: ' + repr(self.resource) + ' ' +\
10512            '>'
10513
10514    def to_dict(self):
10515        return {
10516            'meta': self.meta,
10517            'rate_limit': self.rate_limit,
10518            'resource': self.resource,
10519        }
10520
10521    @classmethod
10522    def from_dict(cls, d):
10523        return cls(
10524            meta=d.get('meta'),
10525            rate_limit=d.get('rate_limit'),
10526            resource=d.get('resource'),
10527        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10488    def __init__(
10489        self,
10490        meta=None,
10491        rate_limit=None,
10492        resource=None,
10493    ):
10494        self.meta = meta if meta is not None else None
10495        '''
10496         Reserved for future use.
10497        '''
10498        self.rate_limit = rate_limit if rate_limit is not None else None
10499        '''
10500         Rate limit information.
10501        '''
10502        self.resource = resource if resource is not None else None
10503        '''
10504         The requested Resource.
10505        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10514    def to_dict(self):
10515        return {
10516            'meta': self.meta,
10517            'rate_limit': self.rate_limit,
10518            'resource': self.resource,
10519        }
@classmethod
def from_dict(cls, d)
10521    @classmethod
10522    def from_dict(cls, d):
10523        return cls(
10524            meta=d.get('meta'),
10525            rate_limit=d.get('rate_limit'),
10526            resource=d.get('resource'),
10527        )
class ResourceUpdateResponse:
10530class ResourceUpdateResponse:
10531    '''
10532         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10533     a ResourceUpdateRequest.
10534    '''
10535    __slots__ = [
10536        'meta',
10537        'rate_limit',
10538        'resource',
10539    ]
10540
10541    def __init__(
10542        self,
10543        meta=None,
10544        rate_limit=None,
10545        resource=None,
10546    ):
10547        self.meta = meta if meta is not None else None
10548        '''
10549         Reserved for future use.
10550        '''
10551        self.rate_limit = rate_limit if rate_limit is not None else None
10552        '''
10553         Rate limit information.
10554        '''
10555        self.resource = resource if resource is not None else None
10556        '''
10557         The updated Resource.
10558        '''
10559
10560    def __repr__(self):
10561        return '<sdm.ResourceUpdateResponse ' + \
10562            'meta: ' + repr(self.meta) + ' ' +\
10563            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10564            'resource: ' + repr(self.resource) + ' ' +\
10565            '>'
10566
10567    def to_dict(self):
10568        return {
10569            'meta': self.meta,
10570            'rate_limit': self.rate_limit,
10571            'resource': self.resource,
10572        }
10573
10574    @classmethod
10575    def from_dict(cls, d):
10576        return cls(
10577            meta=d.get('meta'),
10578            rate_limit=d.get('rate_limit'),
10579            resource=d.get('resource'),
10580        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10541    def __init__(
10542        self,
10543        meta=None,
10544        rate_limit=None,
10545        resource=None,
10546    ):
10547        self.meta = meta if meta is not None else None
10548        '''
10549         Reserved for future use.
10550        '''
10551        self.rate_limit = rate_limit if rate_limit is not None else None
10552        '''
10553         Rate limit information.
10554        '''
10555        self.resource = resource if resource is not None else None
10556        '''
10557         The updated Resource.
10558        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10567    def to_dict(self):
10568        return {
10569            'meta': self.meta,
10570            'rate_limit': self.rate_limit,
10571            'resource': self.resource,
10572        }
@classmethod
def from_dict(cls, d)
10574    @classmethod
10575    def from_dict(cls, d):
10576        return cls(
10577            meta=d.get('meta'),
10578            rate_limit=d.get('rate_limit'),
10579            resource=d.get('resource'),
10580        )
class Role:
10583class Role:
10584    '''
10585         A Role has a list of access rules which determine which Resources the members
10586     of the Role have access to. An Account can be a member of multiple Roles via
10587     AccountAttachments.
10588    '''
10589    __slots__ = [
10590        'access_rules',
10591        'id',
10592        'managed_by',
10593        'name',
10594        'tags',
10595    ]
10596
10597    def __init__(
10598        self,
10599        access_rules=None,
10600        id=None,
10601        managed_by=None,
10602        name=None,
10603        tags=None,
10604    ):
10605        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10606        )
10607        '''
10608         AccessRules is a list of access rules defining the resources this Role has access to.
10609        '''
10610        self.id = id if id is not None else ''
10611        '''
10612         Unique identifier of the Role.
10613        '''
10614        self.managed_by = managed_by if managed_by is not None else ''
10615        '''
10616         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10617        '''
10618        self.name = name if name is not None else ''
10619        '''
10620         Unique human-readable name of the Role.
10621        '''
10622        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10623        '''
10624         Tags is a map of key, value pairs.
10625        '''
10626
10627    def __repr__(self):
10628        return '<sdm.Role ' + \
10629            'access_rules: ' + repr(self.access_rules) + ' ' +\
10630            'id: ' + repr(self.id) + ' ' +\
10631            'managed_by: ' + repr(self.managed_by) + ' ' +\
10632            'name: ' + repr(self.name) + ' ' +\
10633            'tags: ' + repr(self.tags) + ' ' +\
10634            '>'
10635
10636    def to_dict(self):
10637        return {
10638            'access_rules': self.access_rules,
10639            'id': self.id,
10640            'managed_by': self.managed_by,
10641            'name': self.name,
10642            'tags': self.tags,
10643        }
10644
10645    @classmethod
10646    def from_dict(cls, d):
10647        return cls(
10648            access_rules=d.get('access_rules'),
10649            id=d.get('id'),
10650            managed_by=d.get('managed_by'),
10651            name=d.get('name'),
10652            tags=d.get('tags'),
10653        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, managed_by=None, name=None, tags=None)
10597    def __init__(
10598        self,
10599        access_rules=None,
10600        id=None,
10601        managed_by=None,
10602        name=None,
10603        tags=None,
10604    ):
10605        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10606        )
10607        '''
10608         AccessRules is a list of access rules defining the resources this Role has access to.
10609        '''
10610        self.id = id if id is not None else ''
10611        '''
10612         Unique identifier of the Role.
10613        '''
10614        self.managed_by = managed_by if managed_by is not None else ''
10615        '''
10616         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10617        '''
10618        self.name = name if name is not None else ''
10619        '''
10620         Unique human-readable name of the Role.
10621        '''
10622        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10623        '''
10624         Tags is a map of key, value pairs.
10625        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

managed_by

Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10636    def to_dict(self):
10637        return {
10638            'access_rules': self.access_rules,
10639            'id': self.id,
10640            'managed_by': self.managed_by,
10641            'name': self.name,
10642            'tags': self.tags,
10643        }
@classmethod
def from_dict(cls, d)
10645    @classmethod
10646    def from_dict(cls, d):
10647        return cls(
10648            access_rules=d.get('access_rules'),
10649            id=d.get('id'),
10650            managed_by=d.get('managed_by'),
10651            name=d.get('name'),
10652            tags=d.get('tags'),
10653        )
class RoleCreateResponse:
10656class RoleCreateResponse:
10657    '''
10658         RoleCreateResponse reports how the Roles were created in the system. It can
10659     communicate partial successes or failures.
10660    '''
10661    __slots__ = [
10662        'meta',
10663        'rate_limit',
10664        'role',
10665    ]
10666
10667    def __init__(
10668        self,
10669        meta=None,
10670        rate_limit=None,
10671        role=None,
10672    ):
10673        self.meta = meta if meta is not None else None
10674        '''
10675         Reserved for future use.
10676        '''
10677        self.rate_limit = rate_limit if rate_limit is not None else None
10678        '''
10679         Rate limit information.
10680        '''
10681        self.role = role if role is not None else None
10682        '''
10683         The created Role.
10684        '''
10685
10686    def __repr__(self):
10687        return '<sdm.RoleCreateResponse ' + \
10688            'meta: ' + repr(self.meta) + ' ' +\
10689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10690            'role: ' + repr(self.role) + ' ' +\
10691            '>'
10692
10693    def to_dict(self):
10694        return {
10695            'meta': self.meta,
10696            'rate_limit': self.rate_limit,
10697            'role': self.role,
10698        }
10699
10700    @classmethod
10701    def from_dict(cls, d):
10702        return cls(
10703            meta=d.get('meta'),
10704            rate_limit=d.get('rate_limit'),
10705            role=d.get('role'),
10706        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
10667    def __init__(
10668        self,
10669        meta=None,
10670        rate_limit=None,
10671        role=None,
10672    ):
10673        self.meta = meta if meta is not None else None
10674        '''
10675         Reserved for future use.
10676        '''
10677        self.rate_limit = rate_limit if rate_limit is not None else None
10678        '''
10679         Rate limit information.
10680        '''
10681        self.role = role if role is not None else None
10682        '''
10683         The created Role.
10684        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
10693    def to_dict(self):
10694        return {
10695            'meta': self.meta,
10696            'rate_limit': self.rate_limit,
10697            'role': self.role,
10698        }
@classmethod
def from_dict(cls, d)
10700    @classmethod
10701    def from_dict(cls, d):
10702        return cls(
10703            meta=d.get('meta'),
10704            rate_limit=d.get('rate_limit'),
10705            role=d.get('role'),
10706        )
class RoleDeleteResponse:
10709class RoleDeleteResponse:
10710    '''
10711         RoleDeleteResponse returns information about a Role that was deleted.
10712    '''
10713    __slots__ = [
10714        'meta',
10715        'rate_limit',
10716    ]
10717
10718    def __init__(
10719        self,
10720        meta=None,
10721        rate_limit=None,
10722    ):
10723        self.meta = meta if meta is not None else None
10724        '''
10725         Reserved for future use.
10726        '''
10727        self.rate_limit = rate_limit if rate_limit is not None else None
10728        '''
10729         Rate limit information.
10730        '''
10731
10732    def __repr__(self):
10733        return '<sdm.RoleDeleteResponse ' + \
10734            'meta: ' + repr(self.meta) + ' ' +\
10735            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10736            '>'
10737
10738    def to_dict(self):
10739        return {
10740            'meta': self.meta,
10741            'rate_limit': self.rate_limit,
10742        }
10743
10744    @classmethod
10745    def from_dict(cls, d):
10746        return cls(
10747            meta=d.get('meta'),
10748            rate_limit=d.get('rate_limit'),
10749        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
10718    def __init__(
10719        self,
10720        meta=None,
10721        rate_limit=None,
10722    ):
10723        self.meta = meta if meta is not None else None
10724        '''
10725         Reserved for future use.
10726        '''
10727        self.rate_limit = rate_limit if rate_limit is not None else None
10728        '''
10729         Rate limit information.
10730        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10738    def to_dict(self):
10739        return {
10740            'meta': self.meta,
10741            'rate_limit': self.rate_limit,
10742        }
@classmethod
def from_dict(cls, d)
10744    @classmethod
10745    def from_dict(cls, d):
10746        return cls(
10747            meta=d.get('meta'),
10748            rate_limit=d.get('rate_limit'),
10749        )
class RoleGetResponse:
10752class RoleGetResponse:
10753    '''
10754         RoleGetResponse returns a requested Role.
10755    '''
10756    __slots__ = [
10757        'meta',
10758        'rate_limit',
10759        'role',
10760    ]
10761
10762    def __init__(
10763        self,
10764        meta=None,
10765        rate_limit=None,
10766        role=None,
10767    ):
10768        self.meta = meta if meta is not None else None
10769        '''
10770         Reserved for future use.
10771        '''
10772        self.rate_limit = rate_limit if rate_limit is not None else None
10773        '''
10774         Rate limit information.
10775        '''
10776        self.role = role if role is not None else None
10777        '''
10778         The requested Role.
10779        '''
10780
10781    def __repr__(self):
10782        return '<sdm.RoleGetResponse ' + \
10783            'meta: ' + repr(self.meta) + ' ' +\
10784            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10785            'role: ' + repr(self.role) + ' ' +\
10786            '>'
10787
10788    def to_dict(self):
10789        return {
10790            'meta': self.meta,
10791            'rate_limit': self.rate_limit,
10792            'role': self.role,
10793        }
10794
10795    @classmethod
10796    def from_dict(cls, d):
10797        return cls(
10798            meta=d.get('meta'),
10799            rate_limit=d.get('rate_limit'),
10800            role=d.get('role'),
10801        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
10762    def __init__(
10763        self,
10764        meta=None,
10765        rate_limit=None,
10766        role=None,
10767    ):
10768        self.meta = meta if meta is not None else None
10769        '''
10770         Reserved for future use.
10771        '''
10772        self.rate_limit = rate_limit if rate_limit is not None else None
10773        '''
10774         Rate limit information.
10775        '''
10776        self.role = role if role is not None else None
10777        '''
10778         The requested Role.
10779        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10788    def to_dict(self):
10789        return {
10790            'meta': self.meta,
10791            'rate_limit': self.rate_limit,
10792            'role': self.role,
10793        }
@classmethod
def from_dict(cls, d)
10795    @classmethod
10796    def from_dict(cls, d):
10797        return cls(
10798            meta=d.get('meta'),
10799            rate_limit=d.get('rate_limit'),
10800            role=d.get('role'),
10801        )
class RoleUpdateResponse:
10804class RoleUpdateResponse:
10805    '''
10806         RoleUpdateResponse returns the fields of a Role after it has been updated by
10807     a RoleUpdateRequest.
10808    '''
10809    __slots__ = [
10810        'meta',
10811        'rate_limit',
10812        'role',
10813    ]
10814
10815    def __init__(
10816        self,
10817        meta=None,
10818        rate_limit=None,
10819        role=None,
10820    ):
10821        self.meta = meta if meta is not None else None
10822        '''
10823         Reserved for future use.
10824        '''
10825        self.rate_limit = rate_limit if rate_limit is not None else None
10826        '''
10827         Rate limit information.
10828        '''
10829        self.role = role if role is not None else None
10830        '''
10831         The updated Role.
10832        '''
10833
10834    def __repr__(self):
10835        return '<sdm.RoleUpdateResponse ' + \
10836            'meta: ' + repr(self.meta) + ' ' +\
10837            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10838            'role: ' + repr(self.role) + ' ' +\
10839            '>'
10840
10841    def to_dict(self):
10842        return {
10843            'meta': self.meta,
10844            'rate_limit': self.rate_limit,
10845            'role': self.role,
10846        }
10847
10848    @classmethod
10849    def from_dict(cls, d):
10850        return cls(
10851            meta=d.get('meta'),
10852            rate_limit=d.get('rate_limit'),
10853            role=d.get('role'),
10854        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10815    def __init__(
10816        self,
10817        meta=None,
10818        rate_limit=None,
10819        role=None,
10820    ):
10821        self.meta = meta if meta is not None else None
10822        '''
10823         Reserved for future use.
10824        '''
10825        self.rate_limit = rate_limit if rate_limit is not None else None
10826        '''
10827         Rate limit information.
10828        '''
10829        self.role = role if role is not None else None
10830        '''
10831         The updated Role.
10832        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10841    def to_dict(self):
10842        return {
10843            'meta': self.meta,
10844            'rate_limit': self.rate_limit,
10845            'role': self.role,
10846        }
@classmethod
def from_dict(cls, d)
10848    @classmethod
10849    def from_dict(cls, d):
10850        return cls(
10851            meta=d.get('meta'),
10852            rate_limit=d.get('rate_limit'),
10853            role=d.get('role'),
10854        )
class SQLServer:
10857class SQLServer:
10858    __slots__ = [
10859        'bind_interface',
10860        'database',
10861        'egress_filter',
10862        'healthy',
10863        'hostname',
10864        'id',
10865        'name',
10866        'override_database',
10867        'password',
10868        'port',
10869        'port_override',
10870        'schema',
10871        'secret_store_id',
10872        'tags',
10873        'username',
10874    ]
10875
10876    def __init__(
10877        self,
10878        bind_interface=None,
10879        database=None,
10880        egress_filter=None,
10881        healthy=None,
10882        hostname=None,
10883        id=None,
10884        name=None,
10885        override_database=None,
10886        password=None,
10887        port=None,
10888        port_override=None,
10889        schema=None,
10890        secret_store_id=None,
10891        tags=None,
10892        username=None,
10893    ):
10894        self.bind_interface = bind_interface if bind_interface is not None else ''
10895        '''
10896         Bind interface
10897        '''
10898        self.database = database if database is not None else ''
10899        self.egress_filter = egress_filter if egress_filter is not None else ''
10900        '''
10901         A filter applied to the routing logic to pin datasource to nodes.
10902        '''
10903        self.healthy = healthy if healthy is not None else False
10904        '''
10905         True if the datasource is reachable and the credentials are valid.
10906        '''
10907        self.hostname = hostname if hostname is not None else ''
10908        self.id = id if id is not None else ''
10909        '''
10910         Unique identifier of the Resource.
10911        '''
10912        self.name = name if name is not None else ''
10913        '''
10914         Unique human-readable name of the Resource.
10915        '''
10916        self.override_database = override_database if override_database is not None else False
10917        self.password = password if password is not None else ''
10918        self.port = port if port is not None else 0
10919        self.port_override = port_override if port_override is not None else 0
10920        self.schema = schema if schema is not None else ''
10921        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10922        '''
10923         ID of the secret store containing credentials for this resource, if any.
10924        '''
10925        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10926        '''
10927         Tags is a map of key, value pairs.
10928        '''
10929        self.username = username if username is not None else ''
10930
10931    def __repr__(self):
10932        return '<sdm.SQLServer ' + \
10933            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10934            'database: ' + repr(self.database) + ' ' +\
10935            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10936            'healthy: ' + repr(self.healthy) + ' ' +\
10937            'hostname: ' + repr(self.hostname) + ' ' +\
10938            'id: ' + repr(self.id) + ' ' +\
10939            'name: ' + repr(self.name) + ' ' +\
10940            'override_database: ' + repr(self.override_database) + ' ' +\
10941            'password: ' + repr(self.password) + ' ' +\
10942            'port: ' + repr(self.port) + ' ' +\
10943            'port_override: ' + repr(self.port_override) + ' ' +\
10944            'schema: ' + repr(self.schema) + ' ' +\
10945            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10946            'tags: ' + repr(self.tags) + ' ' +\
10947            'username: ' + repr(self.username) + ' ' +\
10948            '>'
10949
10950    def to_dict(self):
10951        return {
10952            'bind_interface': self.bind_interface,
10953            'database': self.database,
10954            'egress_filter': self.egress_filter,
10955            'healthy': self.healthy,
10956            'hostname': self.hostname,
10957            'id': self.id,
10958            'name': self.name,
10959            'override_database': self.override_database,
10960            'password': self.password,
10961            'port': self.port,
10962            'port_override': self.port_override,
10963            'schema': self.schema,
10964            'secret_store_id': self.secret_store_id,
10965            'tags': self.tags,
10966            'username': self.username,
10967        }
10968
10969    @classmethod
10970    def from_dict(cls, d):
10971        return cls(
10972            bind_interface=d.get('bind_interface'),
10973            database=d.get('database'),
10974            egress_filter=d.get('egress_filter'),
10975            healthy=d.get('healthy'),
10976            hostname=d.get('hostname'),
10977            id=d.get('id'),
10978            name=d.get('name'),
10979            override_database=d.get('override_database'),
10980            password=d.get('password'),
10981            port=d.get('port'),
10982            port_override=d.get('port_override'),
10983            schema=d.get('schema'),
10984            secret_store_id=d.get('secret_store_id'),
10985            tags=d.get('tags'),
10986            username=d.get('username'),
10987        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10876    def __init__(
10877        self,
10878        bind_interface=None,
10879        database=None,
10880        egress_filter=None,
10881        healthy=None,
10882        hostname=None,
10883        id=None,
10884        name=None,
10885        override_database=None,
10886        password=None,
10887        port=None,
10888        port_override=None,
10889        schema=None,
10890        secret_store_id=None,
10891        tags=None,
10892        username=None,
10893    ):
10894        self.bind_interface = bind_interface if bind_interface is not None else ''
10895        '''
10896         Bind interface
10897        '''
10898        self.database = database if database is not None else ''
10899        self.egress_filter = egress_filter if egress_filter is not None else ''
10900        '''
10901         A filter applied to the routing logic to pin datasource to nodes.
10902        '''
10903        self.healthy = healthy if healthy is not None else False
10904        '''
10905         True if the datasource is reachable and the credentials are valid.
10906        '''
10907        self.hostname = hostname if hostname is not None else ''
10908        self.id = id if id is not None else ''
10909        '''
10910         Unique identifier of the Resource.
10911        '''
10912        self.name = name if name is not None else ''
10913        '''
10914         Unique human-readable name of the Resource.
10915        '''
10916        self.override_database = override_database if override_database is not None else False
10917        self.password = password if password is not None else ''
10918        self.port = port if port is not None else 0
10919        self.port_override = port_override if port_override is not None else 0
10920        self.schema = schema if schema is not None else ''
10921        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10922        '''
10923         ID of the secret store containing credentials for this resource, if any.
10924        '''
10925        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10926        '''
10927         Tags is a map of key, value pairs.
10928        '''
10929        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10950    def to_dict(self):
10951        return {
10952            'bind_interface': self.bind_interface,
10953            'database': self.database,
10954            'egress_filter': self.egress_filter,
10955            'healthy': self.healthy,
10956            'hostname': self.hostname,
10957            'id': self.id,
10958            'name': self.name,
10959            'override_database': self.override_database,
10960            'password': self.password,
10961            'port': self.port,
10962            'port_override': self.port_override,
10963            'schema': self.schema,
10964            'secret_store_id': self.secret_store_id,
10965            'tags': self.tags,
10966            'username': self.username,
10967        }
@classmethod
def from_dict(cls, d)
10969    @classmethod
10970    def from_dict(cls, d):
10971        return cls(
10972            bind_interface=d.get('bind_interface'),
10973            database=d.get('database'),
10974            egress_filter=d.get('egress_filter'),
10975            healthy=d.get('healthy'),
10976            hostname=d.get('hostname'),
10977            id=d.get('id'),
10978            name=d.get('name'),
10979            override_database=d.get('override_database'),
10980            password=d.get('password'),
10981            port=d.get('port'),
10982            port_override=d.get('port_override'),
10983            schema=d.get('schema'),
10984            secret_store_id=d.get('secret_store_id'),
10985            tags=d.get('tags'),
10986            username=d.get('username'),
10987        )
class SSH:
10990class SSH:
10991    __slots__ = [
10992        'allow_deprecated_key_exchanges',
10993        'bind_interface',
10994        'egress_filter',
10995        'healthy',
10996        'hostname',
10997        'id',
10998        'key_type',
10999        'name',
11000        'port',
11001        'port_forwarding',
11002        'port_override',
11003        'public_key',
11004        'secret_store_id',
11005        'tags',
11006        'username',
11007    ]
11008
11009    def __init__(
11010        self,
11011        allow_deprecated_key_exchanges=None,
11012        bind_interface=None,
11013        egress_filter=None,
11014        healthy=None,
11015        hostname=None,
11016        id=None,
11017        key_type=None,
11018        name=None,
11019        port=None,
11020        port_forwarding=None,
11021        port_override=None,
11022        public_key=None,
11023        secret_store_id=None,
11024        tags=None,
11025        username=None,
11026    ):
11027        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11028        self.bind_interface = bind_interface if bind_interface is not None else ''
11029        '''
11030         Bind interface
11031        '''
11032        self.egress_filter = egress_filter if egress_filter is not None else ''
11033        '''
11034         A filter applied to the routing logic to pin datasource to nodes.
11035        '''
11036        self.healthy = healthy if healthy is not None else False
11037        '''
11038         True if the datasource is reachable and the credentials are valid.
11039        '''
11040        self.hostname = hostname if hostname is not None else ''
11041        self.id = id if id is not None else ''
11042        '''
11043         Unique identifier of the Resource.
11044        '''
11045        self.key_type = key_type if key_type is not None else ''
11046        self.name = name if name is not None else ''
11047        '''
11048         Unique human-readable name of the Resource.
11049        '''
11050        self.port = port if port is not None else 0
11051        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11052        self.port_override = port_override if port_override is not None else 0
11053        self.public_key = public_key if public_key is not None else ''
11054        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11055        '''
11056         ID of the secret store containing credentials for this resource, if any.
11057        '''
11058        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11059        '''
11060         Tags is a map of key, value pairs.
11061        '''
11062        self.username = username if username is not None else ''
11063
11064    def __repr__(self):
11065        return '<sdm.SSH ' + \
11066            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11067            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11068            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11069            'healthy: ' + repr(self.healthy) + ' ' +\
11070            'hostname: ' + repr(self.hostname) + ' ' +\
11071            'id: ' + repr(self.id) + ' ' +\
11072            'key_type: ' + repr(self.key_type) + ' ' +\
11073            'name: ' + repr(self.name) + ' ' +\
11074            'port: ' + repr(self.port) + ' ' +\
11075            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11076            'port_override: ' + repr(self.port_override) + ' ' +\
11077            'public_key: ' + repr(self.public_key) + ' ' +\
11078            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11079            'tags: ' + repr(self.tags) + ' ' +\
11080            'username: ' + repr(self.username) + ' ' +\
11081            '>'
11082
11083    def to_dict(self):
11084        return {
11085            'allow_deprecated_key_exchanges':
11086            self.allow_deprecated_key_exchanges,
11087            'bind_interface': self.bind_interface,
11088            'egress_filter': self.egress_filter,
11089            'healthy': self.healthy,
11090            'hostname': self.hostname,
11091            'id': self.id,
11092            'key_type': self.key_type,
11093            'name': self.name,
11094            'port': self.port,
11095            'port_forwarding': self.port_forwarding,
11096            'port_override': self.port_override,
11097            'public_key': self.public_key,
11098            'secret_store_id': self.secret_store_id,
11099            'tags': self.tags,
11100            'username': self.username,
11101        }
11102
11103    @classmethod
11104    def from_dict(cls, d):
11105        return cls(
11106            allow_deprecated_key_exchanges=d.get(
11107                'allow_deprecated_key_exchanges'),
11108            bind_interface=d.get('bind_interface'),
11109            egress_filter=d.get('egress_filter'),
11110            healthy=d.get('healthy'),
11111            hostname=d.get('hostname'),
11112            id=d.get('id'),
11113            key_type=d.get('key_type'),
11114            name=d.get('name'),
11115            port=d.get('port'),
11116            port_forwarding=d.get('port_forwarding'),
11117            port_override=d.get('port_override'),
11118            public_key=d.get('public_key'),
11119            secret_store_id=d.get('secret_store_id'),
11120            tags=d.get('tags'),
11121            username=d.get('username'),
11122        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
11009    def __init__(
11010        self,
11011        allow_deprecated_key_exchanges=None,
11012        bind_interface=None,
11013        egress_filter=None,
11014        healthy=None,
11015        hostname=None,
11016        id=None,
11017        key_type=None,
11018        name=None,
11019        port=None,
11020        port_forwarding=None,
11021        port_override=None,
11022        public_key=None,
11023        secret_store_id=None,
11024        tags=None,
11025        username=None,
11026    ):
11027        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11028        self.bind_interface = bind_interface if bind_interface is not None else ''
11029        '''
11030         Bind interface
11031        '''
11032        self.egress_filter = egress_filter if egress_filter is not None else ''
11033        '''
11034         A filter applied to the routing logic to pin datasource to nodes.
11035        '''
11036        self.healthy = healthy if healthy is not None else False
11037        '''
11038         True if the datasource is reachable and the credentials are valid.
11039        '''
11040        self.hostname = hostname if hostname is not None else ''
11041        self.id = id if id is not None else ''
11042        '''
11043         Unique identifier of the Resource.
11044        '''
11045        self.key_type = key_type if key_type is not None else ''
11046        self.name = name if name is not None else ''
11047        '''
11048         Unique human-readable name of the Resource.
11049        '''
11050        self.port = port if port is not None else 0
11051        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11052        self.port_override = port_override if port_override is not None else 0
11053        self.public_key = public_key if public_key is not None else ''
11054        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11055        '''
11056         ID of the secret store containing credentials for this resource, if any.
11057        '''
11058        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11059        '''
11060         Tags is a map of key, value pairs.
11061        '''
11062        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11083    def to_dict(self):
11084        return {
11085            'allow_deprecated_key_exchanges':
11086            self.allow_deprecated_key_exchanges,
11087            'bind_interface': self.bind_interface,
11088            'egress_filter': self.egress_filter,
11089            'healthy': self.healthy,
11090            'hostname': self.hostname,
11091            'id': self.id,
11092            'key_type': self.key_type,
11093            'name': self.name,
11094            'port': self.port,
11095            'port_forwarding': self.port_forwarding,
11096            'port_override': self.port_override,
11097            'public_key': self.public_key,
11098            'secret_store_id': self.secret_store_id,
11099            'tags': self.tags,
11100            'username': self.username,
11101        }
@classmethod
def from_dict(cls, d)
11103    @classmethod
11104    def from_dict(cls, d):
11105        return cls(
11106            allow_deprecated_key_exchanges=d.get(
11107                'allow_deprecated_key_exchanges'),
11108            bind_interface=d.get('bind_interface'),
11109            egress_filter=d.get('egress_filter'),
11110            healthy=d.get('healthy'),
11111            hostname=d.get('hostname'),
11112            id=d.get('id'),
11113            key_type=d.get('key_type'),
11114            name=d.get('name'),
11115            port=d.get('port'),
11116            port_forwarding=d.get('port_forwarding'),
11117            port_override=d.get('port_override'),
11118            public_key=d.get('public_key'),
11119            secret_store_id=d.get('secret_store_id'),
11120            tags=d.get('tags'),
11121            username=d.get('username'),
11122        )
class SSHCert:
11125class SSHCert:
11126    __slots__ = [
11127        'allow_deprecated_key_exchanges',
11128        'bind_interface',
11129        'egress_filter',
11130        'healthy',
11131        'hostname',
11132        'id',
11133        'key_type',
11134        'name',
11135        'port',
11136        'port_forwarding',
11137        'port_override',
11138        'remote_identity_group_id',
11139        'remote_identity_healthcheck_username',
11140        'secret_store_id',
11141        'tags',
11142        'username',
11143    ]
11144
11145    def __init__(
11146        self,
11147        allow_deprecated_key_exchanges=None,
11148        bind_interface=None,
11149        egress_filter=None,
11150        healthy=None,
11151        hostname=None,
11152        id=None,
11153        key_type=None,
11154        name=None,
11155        port=None,
11156        port_forwarding=None,
11157        port_override=None,
11158        remote_identity_group_id=None,
11159        remote_identity_healthcheck_username=None,
11160        secret_store_id=None,
11161        tags=None,
11162        username=None,
11163    ):
11164        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11165        self.bind_interface = bind_interface if bind_interface is not None else ''
11166        '''
11167         Bind interface
11168        '''
11169        self.egress_filter = egress_filter if egress_filter is not None else ''
11170        '''
11171         A filter applied to the routing logic to pin datasource to nodes.
11172        '''
11173        self.healthy = healthy if healthy is not None else False
11174        '''
11175         True if the datasource is reachable and the credentials are valid.
11176        '''
11177        self.hostname = hostname if hostname is not None else ''
11178        self.id = id if id is not None else ''
11179        '''
11180         Unique identifier of the Resource.
11181        '''
11182        self.key_type = key_type if key_type is not None else ''
11183        self.name = name if name is not None else ''
11184        '''
11185         Unique human-readable name of the Resource.
11186        '''
11187        self.port = port if port is not None else 0
11188        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11189        self.port_override = port_override if port_override is not None else 0
11190        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11191        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11192        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11193        '''
11194         ID of the secret store containing credentials for this resource, if any.
11195        '''
11196        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11197        '''
11198         Tags is a map of key, value pairs.
11199        '''
11200        self.username = username if username is not None else ''
11201
11202    def __repr__(self):
11203        return '<sdm.SSHCert ' + \
11204            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11205            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11206            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11207            'healthy: ' + repr(self.healthy) + ' ' +\
11208            'hostname: ' + repr(self.hostname) + ' ' +\
11209            'id: ' + repr(self.id) + ' ' +\
11210            'key_type: ' + repr(self.key_type) + ' ' +\
11211            'name: ' + repr(self.name) + ' ' +\
11212            'port: ' + repr(self.port) + ' ' +\
11213            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11214            'port_override: ' + repr(self.port_override) + ' ' +\
11215            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11216            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11218            'tags: ' + repr(self.tags) + ' ' +\
11219            'username: ' + repr(self.username) + ' ' +\
11220            '>'
11221
11222    def to_dict(self):
11223        return {
11224            'allow_deprecated_key_exchanges':
11225            self.allow_deprecated_key_exchanges,
11226            'bind_interface': self.bind_interface,
11227            'egress_filter': self.egress_filter,
11228            'healthy': self.healthy,
11229            'hostname': self.hostname,
11230            'id': self.id,
11231            'key_type': self.key_type,
11232            'name': self.name,
11233            'port': self.port,
11234            'port_forwarding': self.port_forwarding,
11235            'port_override': self.port_override,
11236            'remote_identity_group_id': self.remote_identity_group_id,
11237            'remote_identity_healthcheck_username':
11238            self.remote_identity_healthcheck_username,
11239            'secret_store_id': self.secret_store_id,
11240            'tags': self.tags,
11241            'username': self.username,
11242        }
11243
11244    @classmethod
11245    def from_dict(cls, d):
11246        return cls(
11247            allow_deprecated_key_exchanges=d.get(
11248                'allow_deprecated_key_exchanges'),
11249            bind_interface=d.get('bind_interface'),
11250            egress_filter=d.get('egress_filter'),
11251            healthy=d.get('healthy'),
11252            hostname=d.get('hostname'),
11253            id=d.get('id'),
11254            key_type=d.get('key_type'),
11255            name=d.get('name'),
11256            port=d.get('port'),
11257            port_forwarding=d.get('port_forwarding'),
11258            port_override=d.get('port_override'),
11259            remote_identity_group_id=d.get('remote_identity_group_id'),
11260            remote_identity_healthcheck_username=d.get(
11261                'remote_identity_healthcheck_username'),
11262            secret_store_id=d.get('secret_store_id'),
11263            tags=d.get('tags'),
11264            username=d.get('username'),
11265        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
11145    def __init__(
11146        self,
11147        allow_deprecated_key_exchanges=None,
11148        bind_interface=None,
11149        egress_filter=None,
11150        healthy=None,
11151        hostname=None,
11152        id=None,
11153        key_type=None,
11154        name=None,
11155        port=None,
11156        port_forwarding=None,
11157        port_override=None,
11158        remote_identity_group_id=None,
11159        remote_identity_healthcheck_username=None,
11160        secret_store_id=None,
11161        tags=None,
11162        username=None,
11163    ):
11164        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11165        self.bind_interface = bind_interface if bind_interface is not None else ''
11166        '''
11167         Bind interface
11168        '''
11169        self.egress_filter = egress_filter if egress_filter is not None else ''
11170        '''
11171         A filter applied to the routing logic to pin datasource to nodes.
11172        '''
11173        self.healthy = healthy if healthy is not None else False
11174        '''
11175         True if the datasource is reachable and the credentials are valid.
11176        '''
11177        self.hostname = hostname if hostname is not None else ''
11178        self.id = id if id is not None else ''
11179        '''
11180         Unique identifier of the Resource.
11181        '''
11182        self.key_type = key_type if key_type is not None else ''
11183        self.name = name if name is not None else ''
11184        '''
11185         Unique human-readable name of the Resource.
11186        '''
11187        self.port = port if port is not None else 0
11188        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11189        self.port_override = port_override if port_override is not None else 0
11190        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11191        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11192        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11193        '''
11194         ID of the secret store containing credentials for this resource, if any.
11195        '''
11196        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11197        '''
11198         Tags is a map of key, value pairs.
11199        '''
11200        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11222    def to_dict(self):
11223        return {
11224            'allow_deprecated_key_exchanges':
11225            self.allow_deprecated_key_exchanges,
11226            'bind_interface': self.bind_interface,
11227            'egress_filter': self.egress_filter,
11228            'healthy': self.healthy,
11229            'hostname': self.hostname,
11230            'id': self.id,
11231            'key_type': self.key_type,
11232            'name': self.name,
11233            'port': self.port,
11234            'port_forwarding': self.port_forwarding,
11235            'port_override': self.port_override,
11236            'remote_identity_group_id': self.remote_identity_group_id,
11237            'remote_identity_healthcheck_username':
11238            self.remote_identity_healthcheck_username,
11239            'secret_store_id': self.secret_store_id,
11240            'tags': self.tags,
11241            'username': self.username,
11242        }
@classmethod
def from_dict(cls, d)
11244    @classmethod
11245    def from_dict(cls, d):
11246        return cls(
11247            allow_deprecated_key_exchanges=d.get(
11248                'allow_deprecated_key_exchanges'),
11249            bind_interface=d.get('bind_interface'),
11250            egress_filter=d.get('egress_filter'),
11251            healthy=d.get('healthy'),
11252            hostname=d.get('hostname'),
11253            id=d.get('id'),
11254            key_type=d.get('key_type'),
11255            name=d.get('name'),
11256            port=d.get('port'),
11257            port_forwarding=d.get('port_forwarding'),
11258            port_override=d.get('port_override'),
11259            remote_identity_group_id=d.get('remote_identity_group_id'),
11260            remote_identity_healthcheck_username=d.get(
11261                'remote_identity_healthcheck_username'),
11262            secret_store_id=d.get('secret_store_id'),
11263            tags=d.get('tags'),
11264            username=d.get('username'),
11265        )
class SSHCustomerKey:
11268class SSHCustomerKey:
11269    __slots__ = [
11270        'allow_deprecated_key_exchanges',
11271        'bind_interface',
11272        'egress_filter',
11273        'healthy',
11274        'hostname',
11275        'id',
11276        'name',
11277        'port',
11278        'port_forwarding',
11279        'port_override',
11280        'private_key',
11281        'secret_store_id',
11282        'tags',
11283        'username',
11284    ]
11285
11286    def __init__(
11287        self,
11288        allow_deprecated_key_exchanges=None,
11289        bind_interface=None,
11290        egress_filter=None,
11291        healthy=None,
11292        hostname=None,
11293        id=None,
11294        name=None,
11295        port=None,
11296        port_forwarding=None,
11297        port_override=None,
11298        private_key=None,
11299        secret_store_id=None,
11300        tags=None,
11301        username=None,
11302    ):
11303        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11304        self.bind_interface = bind_interface if bind_interface is not None else ''
11305        '''
11306         Bind interface
11307        '''
11308        self.egress_filter = egress_filter if egress_filter is not None else ''
11309        '''
11310         A filter applied to the routing logic to pin datasource to nodes.
11311        '''
11312        self.healthy = healthy if healthy is not None else False
11313        '''
11314         True if the datasource is reachable and the credentials are valid.
11315        '''
11316        self.hostname = hostname if hostname is not None else ''
11317        self.id = id if id is not None else ''
11318        '''
11319         Unique identifier of the Resource.
11320        '''
11321        self.name = name if name is not None else ''
11322        '''
11323         Unique human-readable name of the Resource.
11324        '''
11325        self.port = port if port is not None else 0
11326        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11327        self.port_override = port_override if port_override is not None else 0
11328        self.private_key = private_key if private_key is not None else ''
11329        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11330        '''
11331         ID of the secret store containing credentials for this resource, if any.
11332        '''
11333        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11334        '''
11335         Tags is a map of key, value pairs.
11336        '''
11337        self.username = username if username is not None else ''
11338
11339    def __repr__(self):
11340        return '<sdm.SSHCustomerKey ' + \
11341            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11342            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11343            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11344            'healthy: ' + repr(self.healthy) + ' ' +\
11345            'hostname: ' + repr(self.hostname) + ' ' +\
11346            'id: ' + repr(self.id) + ' ' +\
11347            'name: ' + repr(self.name) + ' ' +\
11348            'port: ' + repr(self.port) + ' ' +\
11349            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11350            'port_override: ' + repr(self.port_override) + ' ' +\
11351            'private_key: ' + repr(self.private_key) + ' ' +\
11352            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11353            'tags: ' + repr(self.tags) + ' ' +\
11354            'username: ' + repr(self.username) + ' ' +\
11355            '>'
11356
11357    def to_dict(self):
11358        return {
11359            'allow_deprecated_key_exchanges':
11360            self.allow_deprecated_key_exchanges,
11361            'bind_interface': self.bind_interface,
11362            'egress_filter': self.egress_filter,
11363            'healthy': self.healthy,
11364            'hostname': self.hostname,
11365            'id': self.id,
11366            'name': self.name,
11367            'port': self.port,
11368            'port_forwarding': self.port_forwarding,
11369            'port_override': self.port_override,
11370            'private_key': self.private_key,
11371            'secret_store_id': self.secret_store_id,
11372            'tags': self.tags,
11373            'username': self.username,
11374        }
11375
11376    @classmethod
11377    def from_dict(cls, d):
11378        return cls(
11379            allow_deprecated_key_exchanges=d.get(
11380                'allow_deprecated_key_exchanges'),
11381            bind_interface=d.get('bind_interface'),
11382            egress_filter=d.get('egress_filter'),
11383            healthy=d.get('healthy'),
11384            hostname=d.get('hostname'),
11385            id=d.get('id'),
11386            name=d.get('name'),
11387            port=d.get('port'),
11388            port_forwarding=d.get('port_forwarding'),
11389            port_override=d.get('port_override'),
11390            private_key=d.get('private_key'),
11391            secret_store_id=d.get('secret_store_id'),
11392            tags=d.get('tags'),
11393            username=d.get('username'),
11394        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
11286    def __init__(
11287        self,
11288        allow_deprecated_key_exchanges=None,
11289        bind_interface=None,
11290        egress_filter=None,
11291        healthy=None,
11292        hostname=None,
11293        id=None,
11294        name=None,
11295        port=None,
11296        port_forwarding=None,
11297        port_override=None,
11298        private_key=None,
11299        secret_store_id=None,
11300        tags=None,
11301        username=None,
11302    ):
11303        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11304        self.bind_interface = bind_interface if bind_interface is not None else ''
11305        '''
11306         Bind interface
11307        '''
11308        self.egress_filter = egress_filter if egress_filter is not None else ''
11309        '''
11310         A filter applied to the routing logic to pin datasource to nodes.
11311        '''
11312        self.healthy = healthy if healthy is not None else False
11313        '''
11314         True if the datasource is reachable and the credentials are valid.
11315        '''
11316        self.hostname = hostname if hostname is not None else ''
11317        self.id = id if id is not None else ''
11318        '''
11319         Unique identifier of the Resource.
11320        '''
11321        self.name = name if name is not None else ''
11322        '''
11323         Unique human-readable name of the Resource.
11324        '''
11325        self.port = port if port is not None else 0
11326        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11327        self.port_override = port_override if port_override is not None else 0
11328        self.private_key = private_key if private_key is not None else ''
11329        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11330        '''
11331         ID of the secret store containing credentials for this resource, if any.
11332        '''
11333        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11334        '''
11335         Tags is a map of key, value pairs.
11336        '''
11337        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11357    def to_dict(self):
11358        return {
11359            'allow_deprecated_key_exchanges':
11360            self.allow_deprecated_key_exchanges,
11361            'bind_interface': self.bind_interface,
11362            'egress_filter': self.egress_filter,
11363            'healthy': self.healthy,
11364            'hostname': self.hostname,
11365            'id': self.id,
11366            'name': self.name,
11367            'port': self.port,
11368            'port_forwarding': self.port_forwarding,
11369            'port_override': self.port_override,
11370            'private_key': self.private_key,
11371            'secret_store_id': self.secret_store_id,
11372            'tags': self.tags,
11373            'username': self.username,
11374        }
@classmethod
def from_dict(cls, d)
11376    @classmethod
11377    def from_dict(cls, d):
11378        return cls(
11379            allow_deprecated_key_exchanges=d.get(
11380                'allow_deprecated_key_exchanges'),
11381            bind_interface=d.get('bind_interface'),
11382            egress_filter=d.get('egress_filter'),
11383            healthy=d.get('healthy'),
11384            hostname=d.get('hostname'),
11385            id=d.get('id'),
11386            name=d.get('name'),
11387            port=d.get('port'),
11388            port_forwarding=d.get('port_forwarding'),
11389            port_override=d.get('port_override'),
11390            private_key=d.get('private_key'),
11391            secret_store_id=d.get('secret_store_id'),
11392            tags=d.get('tags'),
11393            username=d.get('username'),
11394        )
class SecretStoreCreateResponse:
11397class SecretStoreCreateResponse:
11398    '''
11399         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11400    '''
11401    __slots__ = [
11402        'meta',
11403        'rate_limit',
11404        'secret_store',
11405    ]
11406
11407    def __init__(
11408        self,
11409        meta=None,
11410        rate_limit=None,
11411        secret_store=None,
11412    ):
11413        self.meta = meta if meta is not None else None
11414        '''
11415         Reserved for future use.
11416        '''
11417        self.rate_limit = rate_limit if rate_limit is not None else None
11418        '''
11419         Rate limit information.
11420        '''
11421        self.secret_store = secret_store if secret_store is not None else None
11422        '''
11423         The created SecretStore.
11424        '''
11425
11426    def __repr__(self):
11427        return '<sdm.SecretStoreCreateResponse ' + \
11428            'meta: ' + repr(self.meta) + ' ' +\
11429            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11430            'secret_store: ' + repr(self.secret_store) + ' ' +\
11431            '>'
11432
11433    def to_dict(self):
11434        return {
11435            'meta': self.meta,
11436            'rate_limit': self.rate_limit,
11437            'secret_store': self.secret_store,
11438        }
11439
11440    @classmethod
11441    def from_dict(cls, d):
11442        return cls(
11443            meta=d.get('meta'),
11444            rate_limit=d.get('rate_limit'),
11445            secret_store=d.get('secret_store'),
11446        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
11407    def __init__(
11408        self,
11409        meta=None,
11410        rate_limit=None,
11411        secret_store=None,
11412    ):
11413        self.meta = meta if meta is not None else None
11414        '''
11415         Reserved for future use.
11416        '''
11417        self.rate_limit = rate_limit if rate_limit is not None else None
11418        '''
11419         Rate limit information.
11420        '''
11421        self.secret_store = secret_store if secret_store is not None else None
11422        '''
11423         The created SecretStore.
11424        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
11433    def to_dict(self):
11434        return {
11435            'meta': self.meta,
11436            'rate_limit': self.rate_limit,
11437            'secret_store': self.secret_store,
11438        }
@classmethod
def from_dict(cls, d)
11440    @classmethod
11441    def from_dict(cls, d):
11442        return cls(
11443            meta=d.get('meta'),
11444            rate_limit=d.get('rate_limit'),
11445            secret_store=d.get('secret_store'),
11446        )
class SecretStoreDeleteResponse:
11449class SecretStoreDeleteResponse:
11450    '''
11451         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11452    '''
11453    __slots__ = [
11454        'meta',
11455        'rate_limit',
11456    ]
11457
11458    def __init__(
11459        self,
11460        meta=None,
11461        rate_limit=None,
11462    ):
11463        self.meta = meta if meta is not None else None
11464        '''
11465         Reserved for future use.
11466        '''
11467        self.rate_limit = rate_limit if rate_limit is not None else None
11468        '''
11469         Rate limit information.
11470        '''
11471
11472    def __repr__(self):
11473        return '<sdm.SecretStoreDeleteResponse ' + \
11474            'meta: ' + repr(self.meta) + ' ' +\
11475            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11476            '>'
11477
11478    def to_dict(self):
11479        return {
11480            'meta': self.meta,
11481            'rate_limit': self.rate_limit,
11482        }
11483
11484    @classmethod
11485    def from_dict(cls, d):
11486        return cls(
11487            meta=d.get('meta'),
11488            rate_limit=d.get('rate_limit'),
11489        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
11458    def __init__(
11459        self,
11460        meta=None,
11461        rate_limit=None,
11462    ):
11463        self.meta = meta if meta is not None else None
11464        '''
11465         Reserved for future use.
11466        '''
11467        self.rate_limit = rate_limit if rate_limit is not None else None
11468        '''
11469         Rate limit information.
11470        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11478    def to_dict(self):
11479        return {
11480            'meta': self.meta,
11481            'rate_limit': self.rate_limit,
11482        }
@classmethod
def from_dict(cls, d)
11484    @classmethod
11485    def from_dict(cls, d):
11486        return cls(
11487            meta=d.get('meta'),
11488            rate_limit=d.get('rate_limit'),
11489        )
class SecretStoreGetResponse:
11492class SecretStoreGetResponse:
11493    '''
11494         SecretStoreGetResponse returns a requested SecretStore.
11495    '''
11496    __slots__ = [
11497        'meta',
11498        'rate_limit',
11499        'secret_store',
11500    ]
11501
11502    def __init__(
11503        self,
11504        meta=None,
11505        rate_limit=None,
11506        secret_store=None,
11507    ):
11508        self.meta = meta if meta is not None else None
11509        '''
11510         Reserved for future use.
11511        '''
11512        self.rate_limit = rate_limit if rate_limit is not None else None
11513        '''
11514         Rate limit information.
11515        '''
11516        self.secret_store = secret_store if secret_store is not None else None
11517        '''
11518         The requested SecretStore.
11519        '''
11520
11521    def __repr__(self):
11522        return '<sdm.SecretStoreGetResponse ' + \
11523            'meta: ' + repr(self.meta) + ' ' +\
11524            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11525            'secret_store: ' + repr(self.secret_store) + ' ' +\
11526            '>'
11527
11528    def to_dict(self):
11529        return {
11530            'meta': self.meta,
11531            'rate_limit': self.rate_limit,
11532            'secret_store': self.secret_store,
11533        }
11534
11535    @classmethod
11536    def from_dict(cls, d):
11537        return cls(
11538            meta=d.get('meta'),
11539            rate_limit=d.get('rate_limit'),
11540            secret_store=d.get('secret_store'),
11541        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
11502    def __init__(
11503        self,
11504        meta=None,
11505        rate_limit=None,
11506        secret_store=None,
11507    ):
11508        self.meta = meta if meta is not None else None
11509        '''
11510         Reserved for future use.
11511        '''
11512        self.rate_limit = rate_limit if rate_limit is not None else None
11513        '''
11514         Rate limit information.
11515        '''
11516        self.secret_store = secret_store if secret_store is not None else None
11517        '''
11518         The requested SecretStore.
11519        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
11528    def to_dict(self):
11529        return {
11530            'meta': self.meta,
11531            'rate_limit': self.rate_limit,
11532            'secret_store': self.secret_store,
11533        }
@classmethod
def from_dict(cls, d)
11535    @classmethod
11536    def from_dict(cls, d):
11537        return cls(
11538            meta=d.get('meta'),
11539            rate_limit=d.get('rate_limit'),
11540            secret_store=d.get('secret_store'),
11541        )
class SecretStoreUpdateResponse:
11544class SecretStoreUpdateResponse:
11545    '''
11546         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11547     a SecretStoreUpdateRequest.
11548    '''
11549    __slots__ = [
11550        'meta',
11551        'rate_limit',
11552        'secret_store',
11553    ]
11554
11555    def __init__(
11556        self,
11557        meta=None,
11558        rate_limit=None,
11559        secret_store=None,
11560    ):
11561        self.meta = meta if meta is not None else None
11562        '''
11563         Reserved for future use.
11564        '''
11565        self.rate_limit = rate_limit if rate_limit is not None else None
11566        '''
11567         Rate limit information.
11568        '''
11569        self.secret_store = secret_store if secret_store is not None else None
11570        '''
11571         The updated SecretStore.
11572        '''
11573
11574    def __repr__(self):
11575        return '<sdm.SecretStoreUpdateResponse ' + \
11576            'meta: ' + repr(self.meta) + ' ' +\
11577            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11578            'secret_store: ' + repr(self.secret_store) + ' ' +\
11579            '>'
11580
11581    def to_dict(self):
11582        return {
11583            'meta': self.meta,
11584            'rate_limit': self.rate_limit,
11585            'secret_store': self.secret_store,
11586        }
11587
11588    @classmethod
11589    def from_dict(cls, d):
11590        return cls(
11591            meta=d.get('meta'),
11592            rate_limit=d.get('rate_limit'),
11593            secret_store=d.get('secret_store'),
11594        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
11555    def __init__(
11556        self,
11557        meta=None,
11558        rate_limit=None,
11559        secret_store=None,
11560    ):
11561        self.meta = meta if meta is not None else None
11562        '''
11563         Reserved for future use.
11564        '''
11565        self.rate_limit = rate_limit if rate_limit is not None else None
11566        '''
11567         Rate limit information.
11568        '''
11569        self.secret_store = secret_store if secret_store is not None else None
11570        '''
11571         The updated SecretStore.
11572        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
11581    def to_dict(self):
11582        return {
11583            'meta': self.meta,
11584            'rate_limit': self.rate_limit,
11585            'secret_store': self.secret_store,
11586        }
@classmethod
def from_dict(cls, d)
11588    @classmethod
11589    def from_dict(cls, d):
11590        return cls(
11591            meta=d.get('meta'),
11592            rate_limit=d.get('rate_limit'),
11593            secret_store=d.get('secret_store'),
11594        )
class Service:
11597class Service:
11598    '''
11599         A Service is a service account that can connect to resources they are granted
11600     directly, or granted via roles. Services are typically automated jobs.
11601    '''
11602    __slots__ = [
11603        'id',
11604        'name',
11605        'suspended',
11606        'tags',
11607    ]
11608
11609    def __init__(
11610        self,
11611        id=None,
11612        name=None,
11613        suspended=None,
11614        tags=None,
11615    ):
11616        self.id = id if id is not None else ''
11617        '''
11618         Unique identifier of the Service.
11619        '''
11620        self.name = name if name is not None else ''
11621        '''
11622         Unique human-readable name of the Service.
11623        '''
11624        self.suspended = suspended if suspended is not None else False
11625        '''
11626         The Service's suspended state.
11627        '''
11628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11629        '''
11630         Tags is a map of key, value pairs.
11631        '''
11632
11633    def __repr__(self):
11634        return '<sdm.Service ' + \
11635            'id: ' + repr(self.id) + ' ' +\
11636            'name: ' + repr(self.name) + ' ' +\
11637            'suspended: ' + repr(self.suspended) + ' ' +\
11638            'tags: ' + repr(self.tags) + ' ' +\
11639            '>'
11640
11641    def to_dict(self):
11642        return {
11643            'id': self.id,
11644            'name': self.name,
11645            'suspended': self.suspended,
11646            'tags': self.tags,
11647        }
11648
11649    @classmethod
11650    def from_dict(cls, d):
11651        return cls(
11652            id=d.get('id'),
11653            name=d.get('name'),
11654            suspended=d.get('suspended'),
11655            tags=d.get('tags'),
11656        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
11609    def __init__(
11610        self,
11611        id=None,
11612        name=None,
11613        suspended=None,
11614        tags=None,
11615    ):
11616        self.id = id if id is not None else ''
11617        '''
11618         Unique identifier of the Service.
11619        '''
11620        self.name = name if name is not None else ''
11621        '''
11622         Unique human-readable name of the Service.
11623        '''
11624        self.suspended = suspended if suspended is not None else False
11625        '''
11626         The Service's suspended state.
11627        '''
11628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11629        '''
11630         Tags is a map of key, value pairs.
11631        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11641    def to_dict(self):
11642        return {
11643            'id': self.id,
11644            'name': self.name,
11645            'suspended': self.suspended,
11646            'tags': self.tags,
11647        }
@classmethod
def from_dict(cls, d)
11649    @classmethod
11650    def from_dict(cls, d):
11651        return cls(
11652            id=d.get('id'),
11653            name=d.get('name'),
11654            suspended=d.get('suspended'),
11655            tags=d.get('tags'),
11656        )
class SingleStore:
11659class SingleStore:
11660    __slots__ = [
11661        'bind_interface',
11662        'database',
11663        'egress_filter',
11664        'healthy',
11665        'hostname',
11666        'id',
11667        'name',
11668        'password',
11669        'port',
11670        'port_override',
11671        'secret_store_id',
11672        'tags',
11673        'username',
11674    ]
11675
11676    def __init__(
11677        self,
11678        bind_interface=None,
11679        database=None,
11680        egress_filter=None,
11681        healthy=None,
11682        hostname=None,
11683        id=None,
11684        name=None,
11685        password=None,
11686        port=None,
11687        port_override=None,
11688        secret_store_id=None,
11689        tags=None,
11690        username=None,
11691    ):
11692        self.bind_interface = bind_interface if bind_interface is not None else ''
11693        '''
11694         Bind interface
11695        '''
11696        self.database = database if database is not None else ''
11697        self.egress_filter = egress_filter if egress_filter is not None else ''
11698        '''
11699         A filter applied to the routing logic to pin datasource to nodes.
11700        '''
11701        self.healthy = healthy if healthy is not None else False
11702        '''
11703         True if the datasource is reachable and the credentials are valid.
11704        '''
11705        self.hostname = hostname if hostname is not None else ''
11706        self.id = id if id is not None else ''
11707        '''
11708         Unique identifier of the Resource.
11709        '''
11710        self.name = name if name is not None else ''
11711        '''
11712         Unique human-readable name of the Resource.
11713        '''
11714        self.password = password if password is not None else ''
11715        self.port = port if port is not None else 0
11716        self.port_override = port_override if port_override is not None else 0
11717        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11718        '''
11719         ID of the secret store containing credentials for this resource, if any.
11720        '''
11721        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11722        '''
11723         Tags is a map of key, value pairs.
11724        '''
11725        self.username = username if username is not None else ''
11726
11727    def __repr__(self):
11728        return '<sdm.SingleStore ' + \
11729            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11730            'database: ' + repr(self.database) + ' ' +\
11731            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11732            'healthy: ' + repr(self.healthy) + ' ' +\
11733            'hostname: ' + repr(self.hostname) + ' ' +\
11734            'id: ' + repr(self.id) + ' ' +\
11735            'name: ' + repr(self.name) + ' ' +\
11736            'password: ' + repr(self.password) + ' ' +\
11737            'port: ' + repr(self.port) + ' ' +\
11738            'port_override: ' + repr(self.port_override) + ' ' +\
11739            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11740            'tags: ' + repr(self.tags) + ' ' +\
11741            'username: ' + repr(self.username) + ' ' +\
11742            '>'
11743
11744    def to_dict(self):
11745        return {
11746            'bind_interface': self.bind_interface,
11747            'database': self.database,
11748            'egress_filter': self.egress_filter,
11749            'healthy': self.healthy,
11750            'hostname': self.hostname,
11751            'id': self.id,
11752            'name': self.name,
11753            'password': self.password,
11754            'port': self.port,
11755            'port_override': self.port_override,
11756            'secret_store_id': self.secret_store_id,
11757            'tags': self.tags,
11758            'username': self.username,
11759        }
11760
11761    @classmethod
11762    def from_dict(cls, d):
11763        return cls(
11764            bind_interface=d.get('bind_interface'),
11765            database=d.get('database'),
11766            egress_filter=d.get('egress_filter'),
11767            healthy=d.get('healthy'),
11768            hostname=d.get('hostname'),
11769            id=d.get('id'),
11770            name=d.get('name'),
11771            password=d.get('password'),
11772            port=d.get('port'),
11773            port_override=d.get('port_override'),
11774            secret_store_id=d.get('secret_store_id'),
11775            tags=d.get('tags'),
11776            username=d.get('username'),
11777        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11676    def __init__(
11677        self,
11678        bind_interface=None,
11679        database=None,
11680        egress_filter=None,
11681        healthy=None,
11682        hostname=None,
11683        id=None,
11684        name=None,
11685        password=None,
11686        port=None,
11687        port_override=None,
11688        secret_store_id=None,
11689        tags=None,
11690        username=None,
11691    ):
11692        self.bind_interface = bind_interface if bind_interface is not None else ''
11693        '''
11694         Bind interface
11695        '''
11696        self.database = database if database is not None else ''
11697        self.egress_filter = egress_filter if egress_filter is not None else ''
11698        '''
11699         A filter applied to the routing logic to pin datasource to nodes.
11700        '''
11701        self.healthy = healthy if healthy is not None else False
11702        '''
11703         True if the datasource is reachable and the credentials are valid.
11704        '''
11705        self.hostname = hostname if hostname is not None else ''
11706        self.id = id if id is not None else ''
11707        '''
11708         Unique identifier of the Resource.
11709        '''
11710        self.name = name if name is not None else ''
11711        '''
11712         Unique human-readable name of the Resource.
11713        '''
11714        self.password = password if password is not None else ''
11715        self.port = port if port is not None else 0
11716        self.port_override = port_override if port_override is not None else 0
11717        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11718        '''
11719         ID of the secret store containing credentials for this resource, if any.
11720        '''
11721        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11722        '''
11723         Tags is a map of key, value pairs.
11724        '''
11725        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11744    def to_dict(self):
11745        return {
11746            'bind_interface': self.bind_interface,
11747            'database': self.database,
11748            'egress_filter': self.egress_filter,
11749            'healthy': self.healthy,
11750            'hostname': self.hostname,
11751            'id': self.id,
11752            'name': self.name,
11753            'password': self.password,
11754            'port': self.port,
11755            'port_override': self.port_override,
11756            'secret_store_id': self.secret_store_id,
11757            'tags': self.tags,
11758            'username': self.username,
11759        }
@classmethod
def from_dict(cls, d)
11761    @classmethod
11762    def from_dict(cls, d):
11763        return cls(
11764            bind_interface=d.get('bind_interface'),
11765            database=d.get('database'),
11766            egress_filter=d.get('egress_filter'),
11767            healthy=d.get('healthy'),
11768            hostname=d.get('hostname'),
11769            id=d.get('id'),
11770            name=d.get('name'),
11771            password=d.get('password'),
11772            port=d.get('port'),
11773            port_override=d.get('port_override'),
11774            secret_store_id=d.get('secret_store_id'),
11775            tags=d.get('tags'),
11776            username=d.get('username'),
11777        )
class Snowflake:
11780class Snowflake:
11781    __slots__ = [
11782        'bind_interface',
11783        'database',
11784        'egress_filter',
11785        'healthy',
11786        'hostname',
11787        'id',
11788        'name',
11789        'password',
11790        'port_override',
11791        'schema',
11792        'secret_store_id',
11793        'tags',
11794        'username',
11795    ]
11796
11797    def __init__(
11798        self,
11799        bind_interface=None,
11800        database=None,
11801        egress_filter=None,
11802        healthy=None,
11803        hostname=None,
11804        id=None,
11805        name=None,
11806        password=None,
11807        port_override=None,
11808        schema=None,
11809        secret_store_id=None,
11810        tags=None,
11811        username=None,
11812    ):
11813        self.bind_interface = bind_interface if bind_interface is not None else ''
11814        '''
11815         Bind interface
11816        '''
11817        self.database = database if database is not None else ''
11818        self.egress_filter = egress_filter if egress_filter is not None else ''
11819        '''
11820         A filter applied to the routing logic to pin datasource to nodes.
11821        '''
11822        self.healthy = healthy if healthy is not None else False
11823        '''
11824         True if the datasource is reachable and the credentials are valid.
11825        '''
11826        self.hostname = hostname if hostname is not None else ''
11827        self.id = id if id is not None else ''
11828        '''
11829         Unique identifier of the Resource.
11830        '''
11831        self.name = name if name is not None else ''
11832        '''
11833         Unique human-readable name of the Resource.
11834        '''
11835        self.password = password if password is not None else ''
11836        self.port_override = port_override if port_override is not None else 0
11837        self.schema = schema if schema is not None else ''
11838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11839        '''
11840         ID of the secret store containing credentials for this resource, if any.
11841        '''
11842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11843        '''
11844         Tags is a map of key, value pairs.
11845        '''
11846        self.username = username if username is not None else ''
11847
11848    def __repr__(self):
11849        return '<sdm.Snowflake ' + \
11850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11851            'database: ' + repr(self.database) + ' ' +\
11852            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11853            'healthy: ' + repr(self.healthy) + ' ' +\
11854            'hostname: ' + repr(self.hostname) + ' ' +\
11855            'id: ' + repr(self.id) + ' ' +\
11856            'name: ' + repr(self.name) + ' ' +\
11857            'password: ' + repr(self.password) + ' ' +\
11858            'port_override: ' + repr(self.port_override) + ' ' +\
11859            'schema: ' + repr(self.schema) + ' ' +\
11860            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11861            'tags: ' + repr(self.tags) + ' ' +\
11862            'username: ' + repr(self.username) + ' ' +\
11863            '>'
11864
11865    def to_dict(self):
11866        return {
11867            'bind_interface': self.bind_interface,
11868            'database': self.database,
11869            'egress_filter': self.egress_filter,
11870            'healthy': self.healthy,
11871            'hostname': self.hostname,
11872            'id': self.id,
11873            'name': self.name,
11874            'password': self.password,
11875            'port_override': self.port_override,
11876            'schema': self.schema,
11877            'secret_store_id': self.secret_store_id,
11878            'tags': self.tags,
11879            'username': self.username,
11880        }
11881
11882    @classmethod
11883    def from_dict(cls, d):
11884        return cls(
11885            bind_interface=d.get('bind_interface'),
11886            database=d.get('database'),
11887            egress_filter=d.get('egress_filter'),
11888            healthy=d.get('healthy'),
11889            hostname=d.get('hostname'),
11890            id=d.get('id'),
11891            name=d.get('name'),
11892            password=d.get('password'),
11893            port_override=d.get('port_override'),
11894            schema=d.get('schema'),
11895            secret_store_id=d.get('secret_store_id'),
11896            tags=d.get('tags'),
11897            username=d.get('username'),
11898        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11797    def __init__(
11798        self,
11799        bind_interface=None,
11800        database=None,
11801        egress_filter=None,
11802        healthy=None,
11803        hostname=None,
11804        id=None,
11805        name=None,
11806        password=None,
11807        port_override=None,
11808        schema=None,
11809        secret_store_id=None,
11810        tags=None,
11811        username=None,
11812    ):
11813        self.bind_interface = bind_interface if bind_interface is not None else ''
11814        '''
11815         Bind interface
11816        '''
11817        self.database = database if database is not None else ''
11818        self.egress_filter = egress_filter if egress_filter is not None else ''
11819        '''
11820         A filter applied to the routing logic to pin datasource to nodes.
11821        '''
11822        self.healthy = healthy if healthy is not None else False
11823        '''
11824         True if the datasource is reachable and the credentials are valid.
11825        '''
11826        self.hostname = hostname if hostname is not None else ''
11827        self.id = id if id is not None else ''
11828        '''
11829         Unique identifier of the Resource.
11830        '''
11831        self.name = name if name is not None else ''
11832        '''
11833         Unique human-readable name of the Resource.
11834        '''
11835        self.password = password if password is not None else ''
11836        self.port_override = port_override if port_override is not None else 0
11837        self.schema = schema if schema is not None else ''
11838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11839        '''
11840         ID of the secret store containing credentials for this resource, if any.
11841        '''
11842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11843        '''
11844         Tags is a map of key, value pairs.
11845        '''
11846        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11865    def to_dict(self):
11866        return {
11867            'bind_interface': self.bind_interface,
11868            'database': self.database,
11869            'egress_filter': self.egress_filter,
11870            'healthy': self.healthy,
11871            'hostname': self.hostname,
11872            'id': self.id,
11873            'name': self.name,
11874            'password': self.password,
11875            'port_override': self.port_override,
11876            'schema': self.schema,
11877            'secret_store_id': self.secret_store_id,
11878            'tags': self.tags,
11879            'username': self.username,
11880        }
@classmethod
def from_dict(cls, d)
11882    @classmethod
11883    def from_dict(cls, d):
11884        return cls(
11885            bind_interface=d.get('bind_interface'),
11886            database=d.get('database'),
11887            egress_filter=d.get('egress_filter'),
11888            healthy=d.get('healthy'),
11889            hostname=d.get('hostname'),
11890            id=d.get('id'),
11891            name=d.get('name'),
11892            password=d.get('password'),
11893            port_override=d.get('port_override'),
11894            schema=d.get('schema'),
11895            secret_store_id=d.get('secret_store_id'),
11896            tags=d.get('tags'),
11897            username=d.get('username'),
11898        )
class Snowsight:
11901class Snowsight:
11902    '''
11903    Snowsight is currently unstable, and its API may change, or it may be removed,
11904    without a major version bump.
11905    '''
11906    __slots__ = [
11907        'bind_interface',
11908        'egress_filter',
11909        'healthcheck_username',
11910        'healthy',
11911        'id',
11912        'name',
11913        'port_override',
11914        'samlmetadata',
11915        'secret_store_id',
11916        'subdomain',
11917        'tags',
11918    ]
11919
11920    def __init__(
11921        self,
11922        bind_interface=None,
11923        egress_filter=None,
11924        healthcheck_username=None,
11925        healthy=None,
11926        id=None,
11927        name=None,
11928        port_override=None,
11929        samlmetadata=None,
11930        secret_store_id=None,
11931        subdomain=None,
11932        tags=None,
11933    ):
11934        self.bind_interface = bind_interface if bind_interface is not None else ''
11935        '''
11936         Bind interface
11937        '''
11938        self.egress_filter = egress_filter if egress_filter is not None else ''
11939        '''
11940         A filter applied to the routing logic to pin datasource to nodes.
11941        '''
11942        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11943        self.healthy = healthy if healthy is not None else False
11944        '''
11945         True if the datasource is reachable and the credentials are valid.
11946        '''
11947        self.id = id if id is not None else ''
11948        '''
11949         Unique identifier of the Resource.
11950        '''
11951        self.name = name if name is not None else ''
11952        '''
11953         Unique human-readable name of the Resource.
11954        '''
11955        self.port_override = port_override if port_override is not None else 0
11956        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11958        '''
11959         ID of the secret store containing credentials for this resource, if any.
11960        '''
11961        self.subdomain = subdomain if subdomain is not None else ''
11962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11963        '''
11964         Tags is a map of key, value pairs.
11965        '''
11966
11967    def __repr__(self):
11968        return '<sdm.Snowsight ' + \
11969            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11970            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11971            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11972            'healthy: ' + repr(self.healthy) + ' ' +\
11973            'id: ' + repr(self.id) + ' ' +\
11974            'name: ' + repr(self.name) + ' ' +\
11975            'port_override: ' + repr(self.port_override) + ' ' +\
11976            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11977            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11978            'subdomain: ' + repr(self.subdomain) + ' ' +\
11979            'tags: ' + repr(self.tags) + ' ' +\
11980            '>'
11981
11982    def to_dict(self):
11983        return {
11984            'bind_interface': self.bind_interface,
11985            'egress_filter': self.egress_filter,
11986            'healthcheck_username': self.healthcheck_username,
11987            'healthy': self.healthy,
11988            'id': self.id,
11989            'name': self.name,
11990            'port_override': self.port_override,
11991            'samlmetadata': self.samlmetadata,
11992            'secret_store_id': self.secret_store_id,
11993            'subdomain': self.subdomain,
11994            'tags': self.tags,
11995        }
11996
11997    @classmethod
11998    def from_dict(cls, d):
11999        return cls(
12000            bind_interface=d.get('bind_interface'),
12001            egress_filter=d.get('egress_filter'),
12002            healthcheck_username=d.get('healthcheck_username'),
12003            healthy=d.get('healthy'),
12004            id=d.get('id'),
12005            name=d.get('name'),
12006            port_override=d.get('port_override'),
12007            samlmetadata=d.get('samlmetadata'),
12008            secret_store_id=d.get('secret_store_id'),
12009            subdomain=d.get('subdomain'),
12010            tags=d.get('tags'),
12011        )

Snowsight is currently unstable, and its API may change, or it may be removed, without a major version bump.

Snowsight( bind_interface=None, egress_filter=None, healthcheck_username=None, healthy=None, id=None, name=None, port_override=None, samlmetadata=None, secret_store_id=None, subdomain=None, tags=None)
11920    def __init__(
11921        self,
11922        bind_interface=None,
11923        egress_filter=None,
11924        healthcheck_username=None,
11925        healthy=None,
11926        id=None,
11927        name=None,
11928        port_override=None,
11929        samlmetadata=None,
11930        secret_store_id=None,
11931        subdomain=None,
11932        tags=None,
11933    ):
11934        self.bind_interface = bind_interface if bind_interface is not None else ''
11935        '''
11936         Bind interface
11937        '''
11938        self.egress_filter = egress_filter if egress_filter is not None else ''
11939        '''
11940         A filter applied to the routing logic to pin datasource to nodes.
11941        '''
11942        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11943        self.healthy = healthy if healthy is not None else False
11944        '''
11945         True if the datasource is reachable and the credentials are valid.
11946        '''
11947        self.id = id if id is not None else ''
11948        '''
11949         Unique identifier of the Resource.
11950        '''
11951        self.name = name if name is not None else ''
11952        '''
11953         Unique human-readable name of the Resource.
11954        '''
11955        self.port_override = port_override if port_override is not None else 0
11956        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11958        '''
11959         ID of the secret store containing credentials for this resource, if any.
11960        '''
11961        self.subdomain = subdomain if subdomain is not None else ''
11962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11963        '''
11964         Tags is a map of key, value pairs.
11965        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_username
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
samlmetadata
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
11982    def to_dict(self):
11983        return {
11984            'bind_interface': self.bind_interface,
11985            'egress_filter': self.egress_filter,
11986            'healthcheck_username': self.healthcheck_username,
11987            'healthy': self.healthy,
11988            'id': self.id,
11989            'name': self.name,
11990            'port_override': self.port_override,
11991            'samlmetadata': self.samlmetadata,
11992            'secret_store_id': self.secret_store_id,
11993            'subdomain': self.subdomain,
11994            'tags': self.tags,
11995        }
@classmethod
def from_dict(cls, d)
11997    @classmethod
11998    def from_dict(cls, d):
11999        return cls(
12000            bind_interface=d.get('bind_interface'),
12001            egress_filter=d.get('egress_filter'),
12002            healthcheck_username=d.get('healthcheck_username'),
12003            healthy=d.get('healthy'),
12004            id=d.get('id'),
12005            name=d.get('name'),
12006            port_override=d.get('port_override'),
12007            samlmetadata=d.get('samlmetadata'),
12008            secret_store_id=d.get('secret_store_id'),
12009            subdomain=d.get('subdomain'),
12010            tags=d.get('tags'),
12011        )
class Sybase:
12014class Sybase:
12015    __slots__ = [
12016        'bind_interface',
12017        'egress_filter',
12018        'healthy',
12019        'hostname',
12020        'id',
12021        'name',
12022        'password',
12023        'port',
12024        'port_override',
12025        'secret_store_id',
12026        'tags',
12027        'username',
12028    ]
12029
12030    def __init__(
12031        self,
12032        bind_interface=None,
12033        egress_filter=None,
12034        healthy=None,
12035        hostname=None,
12036        id=None,
12037        name=None,
12038        password=None,
12039        port=None,
12040        port_override=None,
12041        secret_store_id=None,
12042        tags=None,
12043        username=None,
12044    ):
12045        self.bind_interface = bind_interface if bind_interface is not None else ''
12046        '''
12047         Bind interface
12048        '''
12049        self.egress_filter = egress_filter if egress_filter is not None else ''
12050        '''
12051         A filter applied to the routing logic to pin datasource to nodes.
12052        '''
12053        self.healthy = healthy if healthy is not None else False
12054        '''
12055         True if the datasource is reachable and the credentials are valid.
12056        '''
12057        self.hostname = hostname if hostname is not None else ''
12058        self.id = id if id is not None else ''
12059        '''
12060         Unique identifier of the Resource.
12061        '''
12062        self.name = name if name is not None else ''
12063        '''
12064         Unique human-readable name of the Resource.
12065        '''
12066        self.password = password if password is not None else ''
12067        self.port = port if port is not None else 0
12068        self.port_override = port_override if port_override is not None else 0
12069        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12070        '''
12071         ID of the secret store containing credentials for this resource, if any.
12072        '''
12073        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12074        '''
12075         Tags is a map of key, value pairs.
12076        '''
12077        self.username = username if username is not None else ''
12078
12079    def __repr__(self):
12080        return '<sdm.Sybase ' + \
12081            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12082            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12083            'healthy: ' + repr(self.healthy) + ' ' +\
12084            'hostname: ' + repr(self.hostname) + ' ' +\
12085            'id: ' + repr(self.id) + ' ' +\
12086            'name: ' + repr(self.name) + ' ' +\
12087            'password: ' + repr(self.password) + ' ' +\
12088            'port: ' + repr(self.port) + ' ' +\
12089            'port_override: ' + repr(self.port_override) + ' ' +\
12090            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12091            'tags: ' + repr(self.tags) + ' ' +\
12092            'username: ' + repr(self.username) + ' ' +\
12093            '>'
12094
12095    def to_dict(self):
12096        return {
12097            'bind_interface': self.bind_interface,
12098            'egress_filter': self.egress_filter,
12099            'healthy': self.healthy,
12100            'hostname': self.hostname,
12101            'id': self.id,
12102            'name': self.name,
12103            'password': self.password,
12104            'port': self.port,
12105            'port_override': self.port_override,
12106            'secret_store_id': self.secret_store_id,
12107            'tags': self.tags,
12108            'username': self.username,
12109        }
12110
12111    @classmethod
12112    def from_dict(cls, d):
12113        return cls(
12114            bind_interface=d.get('bind_interface'),
12115            egress_filter=d.get('egress_filter'),
12116            healthy=d.get('healthy'),
12117            hostname=d.get('hostname'),
12118            id=d.get('id'),
12119            name=d.get('name'),
12120            password=d.get('password'),
12121            port=d.get('port'),
12122            port_override=d.get('port_override'),
12123            secret_store_id=d.get('secret_store_id'),
12124            tags=d.get('tags'),
12125            username=d.get('username'),
12126        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12030    def __init__(
12031        self,
12032        bind_interface=None,
12033        egress_filter=None,
12034        healthy=None,
12035        hostname=None,
12036        id=None,
12037        name=None,
12038        password=None,
12039        port=None,
12040        port_override=None,
12041        secret_store_id=None,
12042        tags=None,
12043        username=None,
12044    ):
12045        self.bind_interface = bind_interface if bind_interface is not None else ''
12046        '''
12047         Bind interface
12048        '''
12049        self.egress_filter = egress_filter if egress_filter is not None else ''
12050        '''
12051         A filter applied to the routing logic to pin datasource to nodes.
12052        '''
12053        self.healthy = healthy if healthy is not None else False
12054        '''
12055         True if the datasource is reachable and the credentials are valid.
12056        '''
12057        self.hostname = hostname if hostname is not None else ''
12058        self.id = id if id is not None else ''
12059        '''
12060         Unique identifier of the Resource.
12061        '''
12062        self.name = name if name is not None else ''
12063        '''
12064         Unique human-readable name of the Resource.
12065        '''
12066        self.password = password if password is not None else ''
12067        self.port = port if port is not None else 0
12068        self.port_override = port_override if port_override is not None else 0
12069        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12070        '''
12071         ID of the secret store containing credentials for this resource, if any.
12072        '''
12073        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12074        '''
12075         Tags is a map of key, value pairs.
12076        '''
12077        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12095    def to_dict(self):
12096        return {
12097            'bind_interface': self.bind_interface,
12098            'egress_filter': self.egress_filter,
12099            'healthy': self.healthy,
12100            'hostname': self.hostname,
12101            'id': self.id,
12102            'name': self.name,
12103            'password': self.password,
12104            'port': self.port,
12105            'port_override': self.port_override,
12106            'secret_store_id': self.secret_store_id,
12107            'tags': self.tags,
12108            'username': self.username,
12109        }
@classmethod
def from_dict(cls, d)
12111    @classmethod
12112    def from_dict(cls, d):
12113        return cls(
12114            bind_interface=d.get('bind_interface'),
12115            egress_filter=d.get('egress_filter'),
12116            healthy=d.get('healthy'),
12117            hostname=d.get('hostname'),
12118            id=d.get('id'),
12119            name=d.get('name'),
12120            password=d.get('password'),
12121            port=d.get('port'),
12122            port_override=d.get('port_override'),
12123            secret_store_id=d.get('secret_store_id'),
12124            tags=d.get('tags'),
12125            username=d.get('username'),
12126        )
class SybaseIQ:
12129class SybaseIQ:
12130    __slots__ = [
12131        'bind_interface',
12132        'egress_filter',
12133        'healthy',
12134        'hostname',
12135        'id',
12136        'name',
12137        'password',
12138        'port',
12139        'port_override',
12140        'secret_store_id',
12141        'tags',
12142        'username',
12143    ]
12144
12145    def __init__(
12146        self,
12147        bind_interface=None,
12148        egress_filter=None,
12149        healthy=None,
12150        hostname=None,
12151        id=None,
12152        name=None,
12153        password=None,
12154        port=None,
12155        port_override=None,
12156        secret_store_id=None,
12157        tags=None,
12158        username=None,
12159    ):
12160        self.bind_interface = bind_interface if bind_interface is not None else ''
12161        '''
12162         Bind interface
12163        '''
12164        self.egress_filter = egress_filter if egress_filter is not None else ''
12165        '''
12166         A filter applied to the routing logic to pin datasource to nodes.
12167        '''
12168        self.healthy = healthy if healthy is not None else False
12169        '''
12170         True if the datasource is reachable and the credentials are valid.
12171        '''
12172        self.hostname = hostname if hostname is not None else ''
12173        self.id = id if id is not None else ''
12174        '''
12175         Unique identifier of the Resource.
12176        '''
12177        self.name = name if name is not None else ''
12178        '''
12179         Unique human-readable name of the Resource.
12180        '''
12181        self.password = password if password is not None else ''
12182        self.port = port if port is not None else 0
12183        self.port_override = port_override if port_override is not None else 0
12184        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12185        '''
12186         ID of the secret store containing credentials for this resource, if any.
12187        '''
12188        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12189        '''
12190         Tags is a map of key, value pairs.
12191        '''
12192        self.username = username if username is not None else ''
12193
12194    def __repr__(self):
12195        return '<sdm.SybaseIQ ' + \
12196            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12197            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12198            'healthy: ' + repr(self.healthy) + ' ' +\
12199            'hostname: ' + repr(self.hostname) + ' ' +\
12200            'id: ' + repr(self.id) + ' ' +\
12201            'name: ' + repr(self.name) + ' ' +\
12202            'password: ' + repr(self.password) + ' ' +\
12203            'port: ' + repr(self.port) + ' ' +\
12204            'port_override: ' + repr(self.port_override) + ' ' +\
12205            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12206            'tags: ' + repr(self.tags) + ' ' +\
12207            'username: ' + repr(self.username) + ' ' +\
12208            '>'
12209
12210    def to_dict(self):
12211        return {
12212            'bind_interface': self.bind_interface,
12213            'egress_filter': self.egress_filter,
12214            'healthy': self.healthy,
12215            'hostname': self.hostname,
12216            'id': self.id,
12217            'name': self.name,
12218            'password': self.password,
12219            'port': self.port,
12220            'port_override': self.port_override,
12221            'secret_store_id': self.secret_store_id,
12222            'tags': self.tags,
12223            'username': self.username,
12224        }
12225
12226    @classmethod
12227    def from_dict(cls, d):
12228        return cls(
12229            bind_interface=d.get('bind_interface'),
12230            egress_filter=d.get('egress_filter'),
12231            healthy=d.get('healthy'),
12232            hostname=d.get('hostname'),
12233            id=d.get('id'),
12234            name=d.get('name'),
12235            password=d.get('password'),
12236            port=d.get('port'),
12237            port_override=d.get('port_override'),
12238            secret_store_id=d.get('secret_store_id'),
12239            tags=d.get('tags'),
12240            username=d.get('username'),
12241        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12145    def __init__(
12146        self,
12147        bind_interface=None,
12148        egress_filter=None,
12149        healthy=None,
12150        hostname=None,
12151        id=None,
12152        name=None,
12153        password=None,
12154        port=None,
12155        port_override=None,
12156        secret_store_id=None,
12157        tags=None,
12158        username=None,
12159    ):
12160        self.bind_interface = bind_interface if bind_interface is not None else ''
12161        '''
12162         Bind interface
12163        '''
12164        self.egress_filter = egress_filter if egress_filter is not None else ''
12165        '''
12166         A filter applied to the routing logic to pin datasource to nodes.
12167        '''
12168        self.healthy = healthy if healthy is not None else False
12169        '''
12170         True if the datasource is reachable and the credentials are valid.
12171        '''
12172        self.hostname = hostname if hostname is not None else ''
12173        self.id = id if id is not None else ''
12174        '''
12175         Unique identifier of the Resource.
12176        '''
12177        self.name = name if name is not None else ''
12178        '''
12179         Unique human-readable name of the Resource.
12180        '''
12181        self.password = password if password is not None else ''
12182        self.port = port if port is not None else 0
12183        self.port_override = port_override if port_override is not None else 0
12184        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12185        '''
12186         ID of the secret store containing credentials for this resource, if any.
12187        '''
12188        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12189        '''
12190         Tags is a map of key, value pairs.
12191        '''
12192        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12210    def to_dict(self):
12211        return {
12212            'bind_interface': self.bind_interface,
12213            'egress_filter': self.egress_filter,
12214            'healthy': self.healthy,
12215            'hostname': self.hostname,
12216            'id': self.id,
12217            'name': self.name,
12218            'password': self.password,
12219            'port': self.port,
12220            'port_override': self.port_override,
12221            'secret_store_id': self.secret_store_id,
12222            'tags': self.tags,
12223            'username': self.username,
12224        }
@classmethod
def from_dict(cls, d)
12226    @classmethod
12227    def from_dict(cls, d):
12228        return cls(
12229            bind_interface=d.get('bind_interface'),
12230            egress_filter=d.get('egress_filter'),
12231            healthy=d.get('healthy'),
12232            hostname=d.get('hostname'),
12233            id=d.get('id'),
12234            name=d.get('name'),
12235            password=d.get('password'),
12236            port=d.get('port'),
12237            port_override=d.get('port_override'),
12238            secret_store_id=d.get('secret_store_id'),
12239            tags=d.get('tags'),
12240            username=d.get('username'),
12241        )
class Tag:
12244class Tag:
12245    __slots__ = [
12246        'name',
12247        'value',
12248    ]
12249
12250    def __init__(
12251        self,
12252        name=None,
12253        value=None,
12254    ):
12255        self.name = name if name is not None else ''
12256        self.value = value if value is not None else ''
12257
12258    def __repr__(self):
12259        return '<sdm.Tag ' + \
12260            'name: ' + repr(self.name) + ' ' +\
12261            'value: ' + repr(self.value) + ' ' +\
12262            '>'
12263
12264    def to_dict(self):
12265        return {
12266            'name': self.name,
12267            'value': self.value,
12268        }
12269
12270    @classmethod
12271    def from_dict(cls, d):
12272        return cls(
12273            name=d.get('name'),
12274            value=d.get('value'),
12275        )
Tag(name=None, value=None)
12250    def __init__(
12251        self,
12252        name=None,
12253        value=None,
12254    ):
12255        self.name = name if name is not None else ''
12256        self.value = value if value is not None else ''
name
value
def to_dict(self)
12264    def to_dict(self):
12265        return {
12266            'name': self.name,
12267            'value': self.value,
12268        }
@classmethod
def from_dict(cls, d)
12270    @classmethod
12271    def from_dict(cls, d):
12272        return cls(
12273            name=d.get('name'),
12274            value=d.get('value'),
12275        )
class Teradata:
12278class Teradata:
12279    __slots__ = [
12280        'bind_interface',
12281        'egress_filter',
12282        'healthy',
12283        'hostname',
12284        'id',
12285        'name',
12286        'password',
12287        'port',
12288        'port_override',
12289        'secret_store_id',
12290        'tags',
12291        'username',
12292    ]
12293
12294    def __init__(
12295        self,
12296        bind_interface=None,
12297        egress_filter=None,
12298        healthy=None,
12299        hostname=None,
12300        id=None,
12301        name=None,
12302        password=None,
12303        port=None,
12304        port_override=None,
12305        secret_store_id=None,
12306        tags=None,
12307        username=None,
12308    ):
12309        self.bind_interface = bind_interface if bind_interface is not None else ''
12310        '''
12311         Bind interface
12312        '''
12313        self.egress_filter = egress_filter if egress_filter is not None else ''
12314        '''
12315         A filter applied to the routing logic to pin datasource to nodes.
12316        '''
12317        self.healthy = healthy if healthy is not None else False
12318        '''
12319         True if the datasource is reachable and the credentials are valid.
12320        '''
12321        self.hostname = hostname if hostname is not None else ''
12322        self.id = id if id is not None else ''
12323        '''
12324         Unique identifier of the Resource.
12325        '''
12326        self.name = name if name is not None else ''
12327        '''
12328         Unique human-readable name of the Resource.
12329        '''
12330        self.password = password if password is not None else ''
12331        self.port = port if port is not None else 0
12332        self.port_override = port_override if port_override is not None else 0
12333        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12334        '''
12335         ID of the secret store containing credentials for this resource, if any.
12336        '''
12337        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12338        '''
12339         Tags is a map of key, value pairs.
12340        '''
12341        self.username = username if username is not None else ''
12342
12343    def __repr__(self):
12344        return '<sdm.Teradata ' + \
12345            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12346            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12347            'healthy: ' + repr(self.healthy) + ' ' +\
12348            'hostname: ' + repr(self.hostname) + ' ' +\
12349            'id: ' + repr(self.id) + ' ' +\
12350            'name: ' + repr(self.name) + ' ' +\
12351            'password: ' + repr(self.password) + ' ' +\
12352            'port: ' + repr(self.port) + ' ' +\
12353            'port_override: ' + repr(self.port_override) + ' ' +\
12354            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12355            'tags: ' + repr(self.tags) + ' ' +\
12356            'username: ' + repr(self.username) + ' ' +\
12357            '>'
12358
12359    def to_dict(self):
12360        return {
12361            'bind_interface': self.bind_interface,
12362            'egress_filter': self.egress_filter,
12363            'healthy': self.healthy,
12364            'hostname': self.hostname,
12365            'id': self.id,
12366            'name': self.name,
12367            'password': self.password,
12368            'port': self.port,
12369            'port_override': self.port_override,
12370            'secret_store_id': self.secret_store_id,
12371            'tags': self.tags,
12372            'username': self.username,
12373        }
12374
12375    @classmethod
12376    def from_dict(cls, d):
12377        return cls(
12378            bind_interface=d.get('bind_interface'),
12379            egress_filter=d.get('egress_filter'),
12380            healthy=d.get('healthy'),
12381            hostname=d.get('hostname'),
12382            id=d.get('id'),
12383            name=d.get('name'),
12384            password=d.get('password'),
12385            port=d.get('port'),
12386            port_override=d.get('port_override'),
12387            secret_store_id=d.get('secret_store_id'),
12388            tags=d.get('tags'),
12389            username=d.get('username'),
12390        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12294    def __init__(
12295        self,
12296        bind_interface=None,
12297        egress_filter=None,
12298        healthy=None,
12299        hostname=None,
12300        id=None,
12301        name=None,
12302        password=None,
12303        port=None,
12304        port_override=None,
12305        secret_store_id=None,
12306        tags=None,
12307        username=None,
12308    ):
12309        self.bind_interface = bind_interface if bind_interface is not None else ''
12310        '''
12311         Bind interface
12312        '''
12313        self.egress_filter = egress_filter if egress_filter is not None else ''
12314        '''
12315         A filter applied to the routing logic to pin datasource to nodes.
12316        '''
12317        self.healthy = healthy if healthy is not None else False
12318        '''
12319         True if the datasource is reachable and the credentials are valid.
12320        '''
12321        self.hostname = hostname if hostname is not None else ''
12322        self.id = id if id is not None else ''
12323        '''
12324         Unique identifier of the Resource.
12325        '''
12326        self.name = name if name is not None else ''
12327        '''
12328         Unique human-readable name of the Resource.
12329        '''
12330        self.password = password if password is not None else ''
12331        self.port = port if port is not None else 0
12332        self.port_override = port_override if port_override is not None else 0
12333        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12334        '''
12335         ID of the secret store containing credentials for this resource, if any.
12336        '''
12337        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12338        '''
12339         Tags is a map of key, value pairs.
12340        '''
12341        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12359    def to_dict(self):
12360        return {
12361            'bind_interface': self.bind_interface,
12362            'egress_filter': self.egress_filter,
12363            'healthy': self.healthy,
12364            'hostname': self.hostname,
12365            'id': self.id,
12366            'name': self.name,
12367            'password': self.password,
12368            'port': self.port,
12369            'port_override': self.port_override,
12370            'secret_store_id': self.secret_store_id,
12371            'tags': self.tags,
12372            'username': self.username,
12373        }
@classmethod
def from_dict(cls, d)
12375    @classmethod
12376    def from_dict(cls, d):
12377        return cls(
12378            bind_interface=d.get('bind_interface'),
12379            egress_filter=d.get('egress_filter'),
12380            healthy=d.get('healthy'),
12381            hostname=d.get('hostname'),
12382            id=d.get('id'),
12383            name=d.get('name'),
12384            password=d.get('password'),
12385            port=d.get('port'),
12386            port_override=d.get('port_override'),
12387            secret_store_id=d.get('secret_store_id'),
12388            tags=d.get('tags'),
12389            username=d.get('username'),
12390        )
class UpdateResponseMetadata:
12393class UpdateResponseMetadata:
12394    '''
12395         UpdateResponseMetadata is reserved for future use.
12396    '''
12397    __slots__ = []
12398
12399    def __init__(self, ):
12400        pass
12401
12402    def __repr__(self):
12403        return '<sdm.UpdateResponseMetadata ' + \
12404            '>'
12405
12406    def to_dict(self):
12407        return {}
12408
12409    @classmethod
12410    def from_dict(cls, d):
12411        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
12399    def __init__(self, ):
12400        pass
def to_dict(self)
12406    def to_dict(self):
12407        return {}
@classmethod
def from_dict(cls, d)
12409    @classmethod
12410    def from_dict(cls, d):
12411        return cls()
class User:
12414class User:
12415    '''
12416         A User can connect to resources they are granted directly, or granted
12417     via roles.
12418    '''
12419    __slots__ = [
12420        'email',
12421        'external_id',
12422        'first_name',
12423        'id',
12424        'last_name',
12425        'managed_by',
12426        'permission_level',
12427        'suspended',
12428        'tags',
12429    ]
12430
12431    def __init__(
12432        self,
12433        email=None,
12434        external_id=None,
12435        first_name=None,
12436        id=None,
12437        last_name=None,
12438        managed_by=None,
12439        permission_level=None,
12440        suspended=None,
12441        tags=None,
12442    ):
12443        self.email = email if email is not None else ''
12444        '''
12445         The User's email address. Must be unique.
12446        '''
12447        self.external_id = external_id if external_id is not None else ''
12448        '''
12449         External ID is an alternative unique ID this user is represented by within an external service.
12450        '''
12451        self.first_name = first_name if first_name is not None else ''
12452        '''
12453         The User's first name.
12454        '''
12455        self.id = id if id is not None else ''
12456        '''
12457         Unique identifier of the User.
12458        '''
12459        self.last_name = last_name if last_name is not None else ''
12460        '''
12461         The User's last name.
12462        '''
12463        self.managed_by = managed_by if managed_by is not None else ''
12464        '''
12465         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12466        '''
12467        self.permission_level = permission_level if permission_level is not None else ''
12468        '''
12469         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12470        '''
12471        self.suspended = suspended if suspended is not None else False
12472        '''
12473         The User's suspended state.
12474        '''
12475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12476        '''
12477         Tags is a map of key, value pairs.
12478        '''
12479
12480    def __repr__(self):
12481        return '<sdm.User ' + \
12482            'email: ' + repr(self.email) + ' ' +\
12483            'external_id: ' + repr(self.external_id) + ' ' +\
12484            'first_name: ' + repr(self.first_name) + ' ' +\
12485            'id: ' + repr(self.id) + ' ' +\
12486            'last_name: ' + repr(self.last_name) + ' ' +\
12487            'managed_by: ' + repr(self.managed_by) + ' ' +\
12488            'permission_level: ' + repr(self.permission_level) + ' ' +\
12489            'suspended: ' + repr(self.suspended) + ' ' +\
12490            'tags: ' + repr(self.tags) + ' ' +\
12491            '>'
12492
12493    def to_dict(self):
12494        return {
12495            'email': self.email,
12496            'external_id': self.external_id,
12497            'first_name': self.first_name,
12498            'id': self.id,
12499            'last_name': self.last_name,
12500            'managed_by': self.managed_by,
12501            'permission_level': self.permission_level,
12502            'suspended': self.suspended,
12503            'tags': self.tags,
12504        }
12505
12506    @classmethod
12507    def from_dict(cls, d):
12508        return cls(
12509            email=d.get('email'),
12510            external_id=d.get('external_id'),
12511            first_name=d.get('first_name'),
12512            id=d.get('id'),
12513            last_name=d.get('last_name'),
12514            managed_by=d.get('managed_by'),
12515            permission_level=d.get('permission_level'),
12516            suspended=d.get('suspended'),
12517            tags=d.get('tags'),
12518        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, external_id=None, first_name=None, id=None, last_name=None, managed_by=None, permission_level=None, suspended=None, tags=None)
12431    def __init__(
12432        self,
12433        email=None,
12434        external_id=None,
12435        first_name=None,
12436        id=None,
12437        last_name=None,
12438        managed_by=None,
12439        permission_level=None,
12440        suspended=None,
12441        tags=None,
12442    ):
12443        self.email = email if email is not None else ''
12444        '''
12445         The User's email address. Must be unique.
12446        '''
12447        self.external_id = external_id if external_id is not None else ''
12448        '''
12449         External ID is an alternative unique ID this user is represented by within an external service.
12450        '''
12451        self.first_name = first_name if first_name is not None else ''
12452        '''
12453         The User's first name.
12454        '''
12455        self.id = id if id is not None else ''
12456        '''
12457         Unique identifier of the User.
12458        '''
12459        self.last_name = last_name if last_name is not None else ''
12460        '''
12461         The User's last name.
12462        '''
12463        self.managed_by = managed_by if managed_by is not None else ''
12464        '''
12465         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12466        '''
12467        self.permission_level = permission_level if permission_level is not None else ''
12468        '''
12469         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12470        '''
12471        self.suspended = suspended if suspended is not None else False
12472        '''
12473         The User's suspended state.
12474        '''
12475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12476        '''
12477         Tags is a map of key, value pairs.
12478        '''
email

The User's email address. Must be unique.

external_id

External ID is an alternative unique ID this user is represented by within an external service.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

managed_by

Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.

permission_level

PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12493    def to_dict(self):
12494        return {
12495            'email': self.email,
12496            'external_id': self.external_id,
12497            'first_name': self.first_name,
12498            'id': self.id,
12499            'last_name': self.last_name,
12500            'managed_by': self.managed_by,
12501            'permission_level': self.permission_level,
12502            'suspended': self.suspended,
12503            'tags': self.tags,
12504        }
@classmethod
def from_dict(cls, d)
12506    @classmethod
12507    def from_dict(cls, d):
12508        return cls(
12509            email=d.get('email'),
12510            external_id=d.get('external_id'),
12511            first_name=d.get('first_name'),
12512            id=d.get('id'),
12513            last_name=d.get('last_name'),
12514            managed_by=d.get('managed_by'),
12515            permission_level=d.get('permission_level'),
12516            suspended=d.get('suspended'),
12517            tags=d.get('tags'),
12518        )
class VaultAppRoleStore:
12521class VaultAppRoleStore:
12522    __slots__ = [
12523        'id',
12524        'name',
12525        'namespace',
12526        'server_address',
12527        'tags',
12528    ]
12529
12530    def __init__(
12531        self,
12532        id=None,
12533        name=None,
12534        namespace=None,
12535        server_address=None,
12536        tags=None,
12537    ):
12538        self.id = id if id is not None else ''
12539        '''
12540         Unique identifier of the SecretStore.
12541        '''
12542        self.name = name if name is not None else ''
12543        '''
12544         Unique human-readable name of the SecretStore.
12545        '''
12546        self.namespace = namespace if namespace is not None else ''
12547        self.server_address = server_address if server_address is not None else ''
12548        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12549        '''
12550         Tags is a map of key, value pairs.
12551        '''
12552
12553    def __repr__(self):
12554        return '<sdm.VaultAppRoleStore ' + \
12555            'id: ' + repr(self.id) + ' ' +\
12556            'name: ' + repr(self.name) + ' ' +\
12557            'namespace: ' + repr(self.namespace) + ' ' +\
12558            'server_address: ' + repr(self.server_address) + ' ' +\
12559            'tags: ' + repr(self.tags) + ' ' +\
12560            '>'
12561
12562    def to_dict(self):
12563        return {
12564            'id': self.id,
12565            'name': self.name,
12566            'namespace': self.namespace,
12567            'server_address': self.server_address,
12568            'tags': self.tags,
12569        }
12570
12571    @classmethod
12572    def from_dict(cls, d):
12573        return cls(
12574            id=d.get('id'),
12575            name=d.get('name'),
12576            namespace=d.get('namespace'),
12577            server_address=d.get('server_address'),
12578            tags=d.get('tags'),
12579        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12530    def __init__(
12531        self,
12532        id=None,
12533        name=None,
12534        namespace=None,
12535        server_address=None,
12536        tags=None,
12537    ):
12538        self.id = id if id is not None else ''
12539        '''
12540         Unique identifier of the SecretStore.
12541        '''
12542        self.name = name if name is not None else ''
12543        '''
12544         Unique human-readable name of the SecretStore.
12545        '''
12546        self.namespace = namespace if namespace is not None else ''
12547        self.server_address = server_address if server_address is not None else ''
12548        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12549        '''
12550         Tags is a map of key, value pairs.
12551        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12562    def to_dict(self):
12563        return {
12564            'id': self.id,
12565            'name': self.name,
12566            'namespace': self.namespace,
12567            'server_address': self.server_address,
12568            'tags': self.tags,
12569        }
@classmethod
def from_dict(cls, d)
12571    @classmethod
12572    def from_dict(cls, d):
12573        return cls(
12574            id=d.get('id'),
12575            name=d.get('name'),
12576            namespace=d.get('namespace'),
12577            server_address=d.get('server_address'),
12578            tags=d.get('tags'),
12579        )
class VaultTLSStore:
12582class VaultTLSStore:
12583    __slots__ = [
12584        'ca_cert_path',
12585        'client_cert_path',
12586        'client_key_path',
12587        'id',
12588        'name',
12589        'namespace',
12590        'server_address',
12591        'tags',
12592    ]
12593
12594    def __init__(
12595        self,
12596        ca_cert_path=None,
12597        client_cert_path=None,
12598        client_key_path=None,
12599        id=None,
12600        name=None,
12601        namespace=None,
12602        server_address=None,
12603        tags=None,
12604    ):
12605        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12606        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12607        self.client_key_path = client_key_path if client_key_path is not None else ''
12608        self.id = id if id is not None else ''
12609        '''
12610         Unique identifier of the SecretStore.
12611        '''
12612        self.name = name if name is not None else ''
12613        '''
12614         Unique human-readable name of the SecretStore.
12615        '''
12616        self.namespace = namespace if namespace is not None else ''
12617        self.server_address = server_address if server_address is not None else ''
12618        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12619        '''
12620         Tags is a map of key, value pairs.
12621        '''
12622
12623    def __repr__(self):
12624        return '<sdm.VaultTLSStore ' + \
12625            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12626            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12627            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12628            'id: ' + repr(self.id) + ' ' +\
12629            'name: ' + repr(self.name) + ' ' +\
12630            'namespace: ' + repr(self.namespace) + ' ' +\
12631            'server_address: ' + repr(self.server_address) + ' ' +\
12632            'tags: ' + repr(self.tags) + ' ' +\
12633            '>'
12634
12635    def to_dict(self):
12636        return {
12637            'ca_cert_path': self.ca_cert_path,
12638            'client_cert_path': self.client_cert_path,
12639            'client_key_path': self.client_key_path,
12640            'id': self.id,
12641            'name': self.name,
12642            'namespace': self.namespace,
12643            'server_address': self.server_address,
12644            'tags': self.tags,
12645        }
12646
12647    @classmethod
12648    def from_dict(cls, d):
12649        return cls(
12650            ca_cert_path=d.get('ca_cert_path'),
12651            client_cert_path=d.get('client_cert_path'),
12652            client_key_path=d.get('client_key_path'),
12653            id=d.get('id'),
12654            name=d.get('name'),
12655            namespace=d.get('namespace'),
12656            server_address=d.get('server_address'),
12657            tags=d.get('tags'),
12658        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
12594    def __init__(
12595        self,
12596        ca_cert_path=None,
12597        client_cert_path=None,
12598        client_key_path=None,
12599        id=None,
12600        name=None,
12601        namespace=None,
12602        server_address=None,
12603        tags=None,
12604    ):
12605        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12606        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12607        self.client_key_path = client_key_path if client_key_path is not None else ''
12608        self.id = id if id is not None else ''
12609        '''
12610         Unique identifier of the SecretStore.
12611        '''
12612        self.name = name if name is not None else ''
12613        '''
12614         Unique human-readable name of the SecretStore.
12615        '''
12616        self.namespace = namespace if namespace is not None else ''
12617        self.server_address = server_address if server_address is not None else ''
12618        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12619        '''
12620         Tags is a map of key, value pairs.
12621        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12635    def to_dict(self):
12636        return {
12637            'ca_cert_path': self.ca_cert_path,
12638            'client_cert_path': self.client_cert_path,
12639            'client_key_path': self.client_key_path,
12640            'id': self.id,
12641            'name': self.name,
12642            'namespace': self.namespace,
12643            'server_address': self.server_address,
12644            'tags': self.tags,
12645        }
@classmethod
def from_dict(cls, d)
12647    @classmethod
12648    def from_dict(cls, d):
12649        return cls(
12650            ca_cert_path=d.get('ca_cert_path'),
12651            client_cert_path=d.get('client_cert_path'),
12652            client_key_path=d.get('client_key_path'),
12653            id=d.get('id'),
12654            name=d.get('name'),
12655            namespace=d.get('namespace'),
12656            server_address=d.get('server_address'),
12657            tags=d.get('tags'),
12658        )
class VaultTokenStore:
12661class VaultTokenStore:
12662    __slots__ = [
12663        'id',
12664        'name',
12665        'namespace',
12666        'server_address',
12667        'tags',
12668    ]
12669
12670    def __init__(
12671        self,
12672        id=None,
12673        name=None,
12674        namespace=None,
12675        server_address=None,
12676        tags=None,
12677    ):
12678        self.id = id if id is not None else ''
12679        '''
12680         Unique identifier of the SecretStore.
12681        '''
12682        self.name = name if name is not None else ''
12683        '''
12684         Unique human-readable name of the SecretStore.
12685        '''
12686        self.namespace = namespace if namespace is not None else ''
12687        self.server_address = server_address if server_address is not None else ''
12688        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12689        '''
12690         Tags is a map of key, value pairs.
12691        '''
12692
12693    def __repr__(self):
12694        return '<sdm.VaultTokenStore ' + \
12695            'id: ' + repr(self.id) + ' ' +\
12696            'name: ' + repr(self.name) + ' ' +\
12697            'namespace: ' + repr(self.namespace) + ' ' +\
12698            'server_address: ' + repr(self.server_address) + ' ' +\
12699            'tags: ' + repr(self.tags) + ' ' +\
12700            '>'
12701
12702    def to_dict(self):
12703        return {
12704            'id': self.id,
12705            'name': self.name,
12706            'namespace': self.namespace,
12707            'server_address': self.server_address,
12708            'tags': self.tags,
12709        }
12710
12711    @classmethod
12712    def from_dict(cls, d):
12713        return cls(
12714            id=d.get('id'),
12715            name=d.get('name'),
12716            namespace=d.get('namespace'),
12717            server_address=d.get('server_address'),
12718            tags=d.get('tags'),
12719        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12670    def __init__(
12671        self,
12672        id=None,
12673        name=None,
12674        namespace=None,
12675        server_address=None,
12676        tags=None,
12677    ):
12678        self.id = id if id is not None else ''
12679        '''
12680         Unique identifier of the SecretStore.
12681        '''
12682        self.name = name if name is not None else ''
12683        '''
12684         Unique human-readable name of the SecretStore.
12685        '''
12686        self.namespace = namespace if namespace is not None else ''
12687        self.server_address = server_address if server_address is not None else ''
12688        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12689        '''
12690         Tags is a map of key, value pairs.
12691        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12702    def to_dict(self):
12703        return {
12704            'id': self.id,
12705            'name': self.name,
12706            'namespace': self.namespace,
12707            'server_address': self.server_address,
12708            'tags': self.tags,
12709        }
@classmethod
def from_dict(cls, d)
12711    @classmethod
12712    def from_dict(cls, d):
12713        return cls(
12714            id=d.get('id'),
12715            name=d.get('name'),
12716            namespace=d.get('namespace'),
12717            server_address=d.get('server_address'),
12718            tags=d.get('tags'),
12719        )